#include <set>       /* for std::set */
#include <map>       /* for std::map */
#include <vector>    /* for std::vector */
#include <bitset>    /* for std::bitset */
#include <deque>     /* for std::deque */
#include <stdio.h>   /* for sprintf */
#include <cmath>     /* for std::pow and other math */
#include <unistd.h>  /* for open, pread, fork */
#include <sys/file.h> /* for flock */
#include <sys/wait.h> /* for waitpid */
#include <fcntl.h>   /* for O_RDWR, O_CREAT */
#include <stdlib.h>  /* for lrand48 */
#include <stdint.h>  /* for uint_least16_t etc. */
#include <algorithm> /* for std::sort */

#include "coroutine.h" /* See http://www.chiark.greenend.org.uk/~sgtatham/coroutines.html */

/******************************************************/
/* defines for interface with emulator                */
/* these are actually defined in fceu's header files, */
/* but I brought them here so that this compiles      */
/**/
enum Keys /* Bitmasks for different buttons */
{
    K_A = 0x01,
    K_B = 0x02,
    K_SE= 0x04,
    K_ST= 0x08,
    K_U = 0x10,
    K_D = 0x20,
    K_L = 0x40,
    K_R = 0x80
};
extern unsigned char RAM[0x800]; /* RAM for reading */
extern void FCEUSS_Save(const char *); /* create savestate to named file */
extern int FCEUSS_Load(const char *);  /* load savestate from named file */
extern int FCEUSS_SaveFP(FILE *);
extern int FCEUSS_LoadFP(FILE *, int);
extern unsigned char CurInput;  /* player 1 input for the next frame */
extern void FCEUI_FrameAdvance();      /* advance frame */

extern void MovieForkIntoTempFiles(); /* called after fork() so that different children won't attempt to write into the same file, garbling it */
extern int BotFrontDisableVideo;      /* this flag can be used to disable video on emulator for maximum speed */
/******************/

/* Method for calculating average */
class Averaging
{
    unsigned n;
    double sum;
public:
    Averaging() : n(0), sum(0) { }
    void Reset() { n=0; sum=0; }
    void Cumulate(double value) { sum += value; ++n; }
    double GetValue() const { return sum / n; }
};


/* struct SaveState encapsulates a savestate object */
struct SaveState
{
    std::vector<unsigned char> Data;

    void Create()
    {
#if defined(FCEU_VERSION_NUMERIC) && FCEU_VERSION_NUMERIC >= 9899 /* fceux */
        memorystream ms;
        FCEUSS_SaveMS(&ms, 0);
        Data.resize(ms.size());
        memcpy(&Data[0], ms.buf(), Data.size());
#else
        FILE*fp = tmpfile();
        FCEUSS_SaveFP(fp);
        rewind(fp);
        
        fseek(fp,0,SEEK_END);
        long pos = ftell(fp);
        rewind(fp);
        
        SaveState result;
        Data.resize(pos);
        fread(&Data[0], 1, pos, fp);
        fclose(fp);
#endif
    }
    void Load() const
    {
#if defined(FCEU_VERSION_NUMERIC) && FCEU_VERSION_NUMERIC >= 9899 /* fceux */
        memorystream ms;
        ms.write( (const char*) &Data[0], Data.size());
        ms.seekg(0);
        FCEUSS_LoadFP(&ms, SSLOADPARAM_NOBACKUP);
#else
        FILE*fp = tmpfile();
        fwrite(&Data[0], 1, Data.size(), fp);
        rewind(fp);
        FCEUSS_LoadFP(fp, 0);
        fclose(fp);
#endif
    }
};


static struct LunarFilenameManager
{
    char LockFileName[512];
    char StateFileName[512];
    
    LunarFilenameManager()
    {
        int botfrontpid = getpid();
        sprintf(LockFileName, "/tmp/botfront-lock-%d", botfrontpid);
        sprintf(StateFileName, "botfrontL-middle-%d", botfrontpid);
    }
} LunarFilenames;
namespace LunarballLaunchManager2ns{
unsigned MAX_FRAMES;
unsigned BALLS_REMAINING;
}

struct LunarballMethods
{
    struct Winner
    {
        /* number pocketed
           best time
           best_model
           savestate
         */
        
        static void GetBest(unsigned& best_pocketed, unsigned& best_time)
        {
            best_pocketed=0; best_time=65535;

            int flags = O_RDWR | O_CREAT;
            
            int fd = open(LunarFilenames.LockFileName, flags, 0600);
            if(fd < 0) return;
            struct autocloser { int f;
                    autocloser(int fd):f(fd){}
                    ~autocloser(){close(f);} }
                au(fd);
            flock(fd, LOCK_EX);
            char Buf[sizeof(unsigned)*30];
            if(pread(fd, Buf, sizeof(Buf), 0) < (int)sizeof(Buf)) return;
            unsigned* const best_pptr     = (unsigned*)&Buf[0];
            unsigned* const best_tptr     = (unsigned*)&Buf[sizeof(unsigned)*10];
            //unsigned* const best_mptr     = (unsigned*)&Buf[sizeof(unsigned)*20];
            best_pocketed = best_pptr[0];
            best_time     = best_tptr[0];
        }
        
        static unsigned GetBestTimeWithPocketCount(unsigned count, unsigned& model)
        {
            int flags = O_RDWR | O_CREAT;
            int fd = open(LunarFilenames.LockFileName, flags, 0600);
            if(fd < 0) return 65535;
            struct autocloser { int f;
                    autocloser(int fd):f(fd){}
                    ~autocloser(){close(f);} }
                au(fd);
            flock(fd, LOCK_EX);

            char Buf[sizeof(unsigned)*30];
            if(pread(fd, Buf, sizeof(Buf), 0) < (int)sizeof(Buf)) return 65535;
            //unsigned* const best_pptr     = (unsigned*)&Buf[0];
            unsigned* const best_tptr     = (unsigned*)&Buf[sizeof(unsigned)*10];
            unsigned* const best_mptr     = (unsigned*)&Buf[sizeof(unsigned)*20];
            model = best_mptr[count];
            return best_tptr[count];
        }
        
        static double GenRatio(double num_pocketed, double nframes)
        {
            if(nframes < 1) nframes = 1;
            return num_pocketed / (nframes+6);
        }
         
        static bool SetBest(unsigned num_pocketed, unsigned nframes, unsigned model, bool Force)
        {
            using namespace LunarballLaunchManager2ns;
    
            int flags = O_RDWR | O_CREAT | (Force ? O_TRUNC : 0);
            int fd = open(LunarFilenames.LockFileName, flags, 0600);
            struct autocloser { int f;
                    autocloser(int fd):f(fd){}
                    ~autocloser(){close(f);} }
                au(fd);
            
            flock(fd, LOCK_EX);

            char Buf[sizeof(unsigned)*30] = { 0 };
            pread(fd, Buf, sizeof(Buf), 0);
            unsigned* const best_pptr     = (unsigned*)&Buf[0];                   // 0x00
            unsigned* const best_tptr     = (unsigned*)&Buf[sizeof(unsigned)*10]; // 0x28
            unsigned* const best_mptr     = (unsigned*)&Buf[sizeof(unsigned)*20]; // 0x50
            
            unsigned& best_pocketed = best_pptr[0];
            unsigned& best_time     = best_tptr[0];
            unsigned& best_model    = best_mptr[0];
            
            if(!Force)
            {
                double ratio_now = GenRatio(num_pocketed, nframes);
                double ratio_old = GenRatio(best_pocketed, best_time);
                
                /* If the "now" is subpar, reject it. */
                if(ratio_now < ratio_old || ratio_now == 0.0)
                {
                    /* If regardless we got a better number of pocketing */
                    if(num_pocketed != best_pocketed && num_pocketed > 0)
                    {
                        unsigned& ref_pocketed = best_pptr[num_pocketed];
                        unsigned& ref_time     = best_tptr[num_pocketed];
                        unsigned& ref_model    = best_mptr[num_pocketed];
                        double ratio_ref = GenRatio(ref_pocketed, ref_time);
                        
                        if(ratio_now >= ratio_ref || ref_pocketed == 0 || ratio_ref == 0.0)
                        {
                            unsigned cur = model%65536;
                            unsigned pre = model/65536;
                            
                            fprintf(stderr, "Ignoring: Pocketed %u (time %u, angle %u, velo %u, preangle %u, prevelo %u) (ball at %02X,%02X)\n",
                                num_pocketed, nframes, cur%256, cur/256,
                                                       pre%256, pre/256,
                                                       RAM[0x370], RAM[0x330]
                                   );
                        
                            ref_pocketed = num_pocketed;
                            ref_time     = nframes;
                            ref_model    = model;
                            pwrite(fd, Buf, sizeof(Buf), 0);
                        }
                    }
                    return false;
                }
                /*
                if(num_pocketed < best_pocketed) return false;
                if(num_pocketed == best_pocketed && nframes >= best_time) return false;
                */
                if(ratio_now == ratio_old)
                {
                    unsigned now_cur = model%65536, old_cur = best_model%65536;
                    unsigned now_pre = model/65536, old_pre = best_model/65536;
                    unsigned now_cur_vel = now_cur/256, old_cur_vel = old_cur/256;
                    unsigned now_pre_vel = now_pre/256, old_pre_vel = old_pre/256;

                    if(num_pocketed < best_pocketed) return false;
                    if(now_cur_vel < old_cur_vel) return false;
                    if(now_pre_vel > old_pre_vel) return false;
                    if(model == best_model) return false;
                }
            }

            best_pocketed = num_pocketed;
            best_time     = nframes;
            best_model    = model;
            best_pptr[best_pocketed] = best_pocketed;
            best_tptr[best_pocketed] = best_time;
            best_mptr[best_pocketed] = best_model;
            pwrite(fd, Buf, sizeof(Buf), 0);

            if(!Force)
            {
                unsigned cur = model%65536;
                unsigned pre = model/65536;
                
                fprintf(stderr, "Record: Pocketed %u (time %u, angle %u, velo %u, preangle %u, prevelo %u) (ball at %02X,%02X)\n",
                    best_pocketed, best_time, cur%256, cur/256,
                                              pre%256, pre/256,
                                              RAM[0x370], RAM[0x330]
                       );
                //beststate.Create();
                FCEUSS_Save(LunarFilenames.StateFileName);
                
                if(RAM[0x18E] == 0) // no remaining balls
                    MAX_FRAMES = std::min(MAX_FRAMES, best_time+3);
            }
            
            return true;
        }
        static void Compete(unsigned num_pocketed, unsigned nframes, unsigned model)
        {
            SetBest(num_pocketed, nframes, model, false);
            ContestLimit(num_pocketed, nframes);
        }
        static void Load()
        {
            FCEUSS_Load(LunarFilenames.StateFileName);
        }
        
        static void LoadLimit()
        {
            int flags = O_RDONLY;
            int fd = open(LunarFilenames.LockFileName, flags, 0600);
            if(fd < 0) return;
            struct autocloser { int f;
                    autocloser(int fd):f(fd){}
                    ~autocloser(){close(f);} }
                au(fd);
            flock(fd, LOCK_EX);

            char Buf[sizeof(unsigned)*30];
            if(pread(fd, Buf, sizeof(Buf), 0) < (int)sizeof(Buf)) return;
            
            //unsigned* const best_pptr     = (unsigned*)&Buf[0];
            unsigned* const best_tptr     = (unsigned*)&Buf[sizeof(unsigned)*10];
            //unsigned* const best_mptr     = (unsigned*)&Buf[sizeof(unsigned)*20];
            
            for(unsigned num_pocketed=1; num_pocketed<10; ++num_pocketed)
            {
                unsigned nframes = best_tptr[num_pocketed];
                ContestLimit(num_pocketed, nframes);
            }
        }
        static void ContestLimit(unsigned num_pocketed, unsigned nframes)
        {
            if(!num_pocketed || !nframes) return;
            
            using namespace LunarballLaunchManager2ns;
            
            unsigned max_hope = nframes * BALLS_REMAINING
                                        / num_pocketed;
            if(num_pocketed < BALLS_REMAINING)
                max_hope += 7 + 230;
            else
                max_hope += 3;

            if(max_hope < MAX_FRAMES)
            {
                fprintf(stderr, "[%d]Setting max frame limit to %u\n",
                    (int)getpid(), max_hope);
                MAX_FRAMES = max_hope;
            }
        }
    
    private:
        Winner();
    };

    #undef RunFrameWith
    #define RunFrameWith(k) do { CurInput = (k); FCEUI_FrameAdvance(); scrReturn(1); } while(0)
    
    struct AimingMethod
    {
        unsigned char key;
        bool autofire;
    public:
        AimingMethod() : key(0),autofire(false) { }
        
        void Decide(unsigned wanted, unsigned orig_angle = RAM[0x3C0])
        {
            unsigned plus_dist  = (wanted+256-orig_angle) & 255;
            unsigned minus_dist = (orig_angle+256-wanted) & 255;
            int dir = plus_dist > minus_dist ? -1 : 1;
            unsigned dist = std::min(plus_dist, minus_dist);
            key = dir == 1 ? K_R : K_L;
            unsigned elapse_norepeat = 16 + (dist-1)*1;
            unsigned elapse_repeat = 1 + 2*(dist-1);
            autofire = elapse_repeat <= elapse_norepeat;
        }
        
        bool operator==(const AimingMethod& b) const
            { return key==b.key && autofire==b.autofire; }
        bool operator!=(const AimingMethod& b) const
            { return !operator==(b); }
        bool operator<(const AimingMethod& b) const
            { return (key*2+autofire) < (b.key*2+b.autofire); }
    
        int Run(unsigned angle, unsigned frno, unsigned& frames_begin, unsigned maxframes)
        {
            scrBegin;
            
            // autofire: repeatedly press to the direction
            // !autofire: hold button until angle is right

            while(RAM[0x3C0] != angle)
            {
                RunFrameWith( (autofire && (frno&1)) ? 0x00 : key);
                if(++frames_begin >= maxframes) goto Fail;
            }
        Fail: ;
            scrFinish(0);
        }
    };

    static bool DoAiming(unsigned angle, unsigned& frames_begin, unsigned maxframes)
    {
        //fprintf(stderr, "#1 aiming for angle %u, f(%u)\n", angle, frames_begin);
        scrBegin;
        //fprintf(stderr, "#2 aiming for angle %u, f(%u)\n", angle, frames_begin);
        
        static AimingMethod method;
        method.Decide(angle);

        /*fprintf(stderr, "#M aiming for angle %u, f(%u): %02X,%s, 0x3C0=%u\n",
            angle, frames_begin,
            method.key, method.autofire?"true":"false", RAM[0x3C0]);*/
        
        static unsigned frno; frno=0;
        while(method.Run(angle, frno++, frames_begin, maxframes)) scrReturn(1);
        
        //fprintf(stderr, "#3 aiming for angle %u, f(%u)\n", angle, frames_begin);
        scrFinish(0);
    }
    static bool DoFiring(unsigned& frames_begin, unsigned maxframes)
    {
        scrBegin;
        
        if(!frames_begin) RunFrameWith(0);
        do { RunFrameWith(K_B); ++frames_begin;
            // If white was pocketed or maxframes hit
            if(WhitePocketed() || frames_begin > maxframes) goto Fail;
        } while(RAM[0x3D0] == 0 || RAM[0x3D0] == 0xFF);
        
    Fail:;
        scrFinish(0);
    }
    static bool DoWaitBallsStop(unsigned& nframes, const char*& failreason, unsigned maxframes)
    {
        scrBegin;
        
        while(RAM[0x3D0] != 0 && RAM[0x3D0] != 0xFF)
        {
            if(RAM[0x3A0] == 0)
            {
                // If white ball is not moving, check if all other balls
                // have been pocketed
                for(unsigned b=1; b<16; ++b)
                    if(RAM[0x310+b] < 0x10
                    && RAM[0x300+b] >= 4) goto NotAllPocketed;
                break; // yay!
            NotAllPocketed:;
            }
            
            if(WhitePocketed()) { failreason="blunder"; goto Fail; }
            if(++nframes > maxframes) { failreason="timeout"; goto Fail; }
            //if(frames_begin+nframes >= 300) goto Fail;
            RunFrameWith(0);
        }
    Fail:;
        scrFinish(0);
    }
    static bool DoWaitNextShotPossible(
        unsigned& nframes_total,
        unsigned& nframes_transition,
        bool verbose, unsigned maxframes)
    {
        /* After the shot has been shot, wait
           until the cursor can be moved again.
        */
        scrBegin;
        
        static SaveState tmp;
        static unsigned was_angle, became_angle1, became_angle2;
        static bool transition;
        transition = false;
        
        if(verbose) fprintf(stderr, "Waiting until next shot can be shot\n");
    NextFrameWaiter:
        if(!transition && RAM[0x18F] == 0) transition = true;
        if(nframes_total-nframes_transition > maxframes) goto Fail;
        tmp.Create();
        was_angle = RAM[0x3C0];
        RunFrameWith(K_R); ++nframes_total; if(transition) ++nframes_transition;
        became_angle1 = RAM[0x3C0];
        if(became_angle1 == was_angle) goto NextFrameWaiter;
        // K_R affected angle, check if K_L also affects angle
        
        tmp.Load(); --nframes_total; if(transition) --nframes_transition;
        RunFrameWith(K_L); ++nframes_total; if(transition) ++nframes_transition;
        became_angle2 = RAM[0x3C0];
        if(became_angle2 == was_angle) goto NextFrameWaiter;
        // K_R and K_L both worked
        
        // If Right and Left produced the *same* change, reject this action 
        if(became_angle1 == became_angle2) goto NextFrameWaiter;
        
        // K_R and K_L produced different changes, so we're ready.
        tmp.Load(); --nframes_total; if(transition) --nframes_transition;
    Fail: ;
        scrFinish(0);
    }
    
    static bool DoProfileShot(unsigned& num_pocketed, unsigned& nframes,
        const char*& failreason,
        unsigned maxframes)
    {
        scrBegin;
        
        failreason = 0;
        
        // Count how many balls were pocketed before playing
        static unsigned pocketed_begin;
        pocketed_begin = GetPocketedCount();

        // Fire (and wait until it registers the action)
        while(DoFiring(nframes, maxframes)) scrReturn(1);

        // Wait until all balls stop moving.
        while(DoWaitBallsStop(nframes, failreason, maxframes)) scrReturn(1);
        if(failreason) goto Fail;
        
        num_pocketed = GetPocketedCount();
        if(WhitePocketed()) { failreason="blunder2"; goto Fail; }
        
        /*fprintf(stderr, "frame %u, pocketed %u, begin %u\n",
            (unsigned)framecount,
            num_pocketed,
            pocketed_begin);
        */
        
        if(num_pocketed >= pocketed_begin)
            num_pocketed -= pocketed_begin; else num_pocketed=0;
    
    Fail: ;
        scrFinish(0);
    }

    static unsigned GetPocketedCount()
    {
        unsigned result = 0;
        for(unsigned a=1; a<16;++a)
        {
            if(RAM[0x300+a]==0xC0) break;
            if((RAM[0x300+a] & 15) != 2 && (RAM[0x300+a] & 15) != 1)
            {
                //fprintf(stderr, "%u:%02X;", a,RAM[0x300+a]);
                ++result;
            }
        }
        ++result;
        return result;
    }
    static bool WhitePocketed()
    {
        return  (RAM[0x300] & 15) != 2
             && (RAM[0x300] & 15) != 1;
    }


    static double CalculateProspects()
    {
        /* Returns a value 0..1 describing how good the board state is */
        static std::vector<double> pocket_x;
        static std::vector<double> pocket_y;
        static int LastInitPockets=-1;
        static double maximumdistance;
        
        if(LastInitPockets != RAM[0x187])
        {
            /* To save CPU time, only regenerate
             * the pocket list when the table changes
             */
            pocket_x.clear(); pocket_y.clear();
            LastInitPockets = RAM[0x187];
            
            for(unsigned y=1; y<19; ++y)
            {
                for(unsigned x=1; x<25; ++x)
                {
                    unsigned char c = RAM[0x600 + y*26+x];
                    //fprintf(stderr, "%02X ", c);
                    #define b(n) (((n)&~0xCC)==0)
                    
                    if((c & 0x10) == 0x10 // this indicates a pocket-type tile
                    && (b(RAM[0x600 + (y-1)*26+x]) // must be next to field
                     || b(RAM[0x600 + (y+1)*26+x])
                     || b(RAM[0x600 + y*26+(x-1)])
                     || b(RAM[0x600 + y*26+(x+1)])))
                    {
                        pocket_x.push_back(x);
                        pocket_y.push_back(y);
                        //fprintf(stderr, "\npocket at %u,%u", x,y);
                    }
                    #undef b
                }
                //fprintf(stderr, "\n");
            }

            maximumdistance=0;
            unsigned n_pockets = pocket_x.size();
            for(unsigned y=1; y<19; ++y)
                for(unsigned x=1; x<25; ++x)
                {
                    double mindist=9e39;
                    for(unsigned p=0; p<n_pockets; ++p)
                    {
                        double xd = x-pocket_x[p], yd = y-pocket_y[p];
                        double dist = std::sqrt(xd*xd+yd*yd);
                        if(dist < mindist) mindist=dist;
                    }
                    if(mindist>maximumdistance) maximumdistance=mindist;
                }
        }
        unsigned n_pockets = pocket_x.size();
        
        double result = 0;
        for(unsigned n=1; n<16; ++n)
        {
            unsigned char BallState = RAM[0x300+n];
            if(RAM[0x310+n] == 0 || RAM[0x310+n] >= 0x10) continue; // non-balls
            if(BallState == 0x83 || BallState == 0x03 || BallState == 0x00)
            {
                // The ball does not exist anymore. Perfect.
                //result += 1.0;
                continue;
            }
          
          #if 1
            // Find out how close the ball is to the nearest pocket
            double ballx = int(RAM[0x370 + n] / 8) - 3;
            double bally = int(RAM[0x330 + n] / 8) - 8;
            double mindistsquared = 9e39;
            for(unsigned p=0; p<n_pockets; ++p)
            {
                double xdist = ballx - pocket_x[p], ydist = bally - pocket_y[p];
                double distsquared = xdist*xdist + ydist*ydist;
                if(distsquared < mindistsquared) mindistsquared = distsquared;
            }
            double dist = std::sqrt(mindistsquared);
            
            /*
            fprintf(stderr, "\n[%u/%u][0:%02X 3:%02X 7:%02X] ballx=%6.3f bally=%6.3f dist=%6.3f, maxdist=%g;",
                n, framecount,
                RAM[0x300+n], RAM[0x330+n], RAM[0x370+n],
                ballx,bally,dist, maximumdistance);*/
            
            result += (1.0 - (dist / maximumdistance)) * 0.5;
          #endif
        }
        //fprintf(stderr, "\n");
        
        return result / 6.0;
    }
};

struct LunarballLaunchManager2: public LunarballMethods
{
    // Define the range of parameters to be passed to Mutate().
    static const double MINMUTAATIO = 0.0010; // Minimum value, given to first candidates
    static const double MAXMUTAATIO = 0.7800; // Maximum value, given to last candidates
    // This controls the curve of mutation distribution 
    // (larger value = more big mutations, smaller value = more small mutations).
    // 1 = even distribution
    static const double LOGMUTAATIO = 0.243;
    
    static const unsigned WINNERS = 16; // number of winners to take each round for refinement

    // number of variations per each generation (PLUS WINNERS, which are preserved for competition)
    // larger number increases the chances of finding the Right Thing
    static const unsigned NUM_VARIATIONS = 1900;
    
    // number of entirely randomly generated candidates to add each round
    static const unsigned NUM_RANDOMS = 300;

    // accept rule when no improvements have been found within this number of generations
    // larger number decreases the chances of missing the Right Thing
    static const unsigned min_generations_no_improvement = 80;

    static const unsigned NUM_FORKS = 4;
    static const unsigned NUM_CANDIDATES_PER_PROCESS = 200;

    static const unsigned INIT_MAX_FRAMES = 670+3;
    
    static const bool DO_DUALSHOT = true;
    static const bool IGNORE_SCORE_DELAYS = false;
    
    /*
        Input:
         For all
           angle
           preangle
           
           try some: prevelocity
           try all: velocity
           
           find best, then refine it
           genetically
    */
    
    struct CandidateType
    {
    private:
        float angle;
        float velocity;
        float preangle;
        float prevelocity;
    public:
        float scoring;
        uint_least16_t confidence;
        bool dummy_first;
        uint_least32_t key;
    public:
        CandidateType(): angle(0),velocity(0),preangle(0),prevelocity(0),
                         scoring(0),confidence(0),dummy_first(false), key(0)
                         { }
        
        void Mutate(double mut_amount)
        {
        retry: ;
            unsigned r = lrand48();
            unsigned which = 1+(r%15), change = r/15;
            unsigned oldmodel = GetModel();
            if(dummy_first) { which = 12 + 1+(r%3); change = r/3;}
            if(which & 1) angle       = fmod(angle       + 1 + ((change&1)?1:-1)*mut_amount, 1);
            if(which & 2) velocity    = fmod(velocity    + 1 + ((change&2)?1:-1)*mut_amount, 1);
            if(which & 4) preangle    = fmod(preangle    + 1 + ((change&4)?1:-1)*mut_amount, 1);
            if(which & 8) prevelocity = fmod(prevelocity + 1 + ((change&8)?1:-1)*mut_amount, 1);
            if(dummy_first)
            {
                if((GetModel() >> 16) == (oldmodel >> 16))
                {
                    if(mut_amount < 0.4) mut_amount += 0.1;
                    goto retry;
                }
                dummy_first = false;
            }
        }
        unsigned GetModel() const
        {
            unsigned char ang = (unsigned)(angle*256)& 0xFF;
            unsigned char vel = (unsigned)(velocity*256) & 0xFF;
            unsigned char preang = (unsigned)(preangle*256) & 0xFF;
            unsigned char prevel = (unsigned)(prevelocity*256) & 0xFF;
            
            /* Game's velocity gauge goes in increments of 3 */
            vel = (vel/3)*3;       if(vel < 0x12)    vel = 0x12;
            prevel = (prevel/3)*3; if(prevel < 0x12) prevel = 0x12;
            
            return (ang + vel*256U) + 65536U * (preang + prevel*256U);
        }
        CandidateType& SetModel(unsigned model, bool dummy=false)
        {
            unsigned cur = model%65536;
            unsigned pre = model/65536;
            
            angle    = (cur%256) / 256.0; preangle    = (pre%256) / 256.0;
            velocity = (cur/256) / 256.0; prevelocity = (pre/256) / 256.0;
            dummy_first = dummy;
            return *this;
        }
        void CreateRandom()
        {
            angle    = drand48(); preangle = drand48();
            velocity = drand48(); prevelocity = drand48();
        }
        
        static unsigned CountSeeds() { return 0; }
        CandidateType& SetSeed(unsigned)
        {
            return *this;
        }

        bool BetterScoring(const CandidateType& b) const
        {
            return scoring > b.scoring;
        }
        void SaveRes()
        {
            char candfn[128]; sprintf(candfn, "/tmp/cand%u.res", key);
            FILE*fp = fopen(candfn, "wt");
            if(fp)
            {
                fprintf(fp, "%g,%d,%d\n",
                    scoring,
                    confidence,
                    (int)dummy_first);
                fclose(fp);
            }
            else
                perror(candfn);
        }
        void LoadRes()
        {
            char candfn[128]; sprintf(candfn, "/tmp/cand%u.res", key);
            if(FILE*fp = fopen(candfn, "rt"))
            {
                int dummy, cf;
                double sc;
                fscanf(fp, "%lg,%d,%d",
                    &sc,
                    &cf,
                    &dummy);
                scoring=sc;
                confidence=cf;
                dummy_first = dummy;
                fclose(fp);
            }
            else
            {
                perror(candfn);
            }
            unlink(candfn);
        }
    };

    typedef
      std::map<unsigned char/*preang*/,
               std::map<unsigned char/*prevel*/,
                   std::map<unsigned char/*ang*/,
                      std::map<unsigned char/*vel*/, CandidateType*>
              > > > CandidateOptMapType;
    
    struct LunarState: public SaveState
    {
        unsigned nmp, nmf, *nmpp, *nmfp;
        LunarState(): SaveState(), nmp(0), nmf(0), nmpp(&nmp), nmfp(&nmf) { }
        
        void Save(unsigned& np, unsigned& nf)
            { SaveState::Create(); nmp=*(nmpp=&np); nmf=*(nmfp=&nf); }
        
        void Load()
            { SaveState::Load(); *nmpp=nmp; *nmfp=nmf; }
    };
    
    bool AnalyzeShotResult(CandidateType& cand, unsigned& num_pocketed, unsigned& nframes,
        unsigned ang,unsigned vel,unsigned preang,unsigned prevel)
    {
        using namespace LunarballLaunchManager2ns;
    
        scrBegin;
        
        static const char* failreason; failreason = 0;
        static unsigned nframes_transition; nframes_transition = 0;
        
      #if 1 /* Don't do this, it hinders the finding of good candidates */
        if(num_pocketed > 0)
        { unsigned dummy_model, best_time_this_pocket_count
            = Winner::GetBestTimeWithPocketCount(num_pocketed,dummy_model);
          if(best_time_this_pocket_count > 0
          && best_time_this_pocket_count*5/3 < nframes)
          {
            /*fprintf(stderr, "estimated %u, got %u\n",
                best_time_this_pocket_count, nframes);*/
            failreason = "pessimistic";
            goto Fail;
          }
        }
      #endif
      
        static double prospects; prospects = CalculateProspects();
        
        if(num_pocketed > 0)
        {
            if(IGNORE_SCORE_DELAYS)
            {
                static unsigned nf1, nf2; nf1=nf2=0;
                while(DoWaitNextShotPossible(
                    nf1, nf2, false, 9999)) scrReturn(1);
            }
            else
            {
                while(DoWaitNextShotPossible(
                    nframes, nframes_transition, false, MAX_FRAMES)) scrReturn(1);
                if(nframes-nframes_transition >= MAX_FRAMES) goto Fail;
            }
        }
        
        static unsigned nframes_scoring;
        nframes_scoring = nframes - nframes_transition;
        cand.scoring = num_pocketed;
        cand.scoring += prospects;
        cand.scoring /= (double)(nframes_scoring ? nframes_scoring : 0);
        cand.scoring *= 131072; // arbitrary number to make the scores more readable
        
        ++cand.confidence;
        goto EndLoop;
    Fail:
        if(!failreason && nframes-nframes_transition >= MAX_FRAMES) failreason="timeout";
        if(!failreason && !num_pocketed) failreason="dummy";
        if(!failreason) failreason="fail";
        if(nframes < nframes_transition) nframes_transition=0;
        
    EndLoop: ;
        // confidence is not increased if a fail happens
        fprintf(stderr, "\rk[%04d]ang[%3d]vel[%3d]preang[%3u]prevel[%3u]: p=%u, f=%u(ef=%u), %2.4f, %-18s%s",
            cand.key,
            ang,vel,preang,prevel,
            num_pocketed, nframes-nframes_transition, nframes_transition,
            cand.scoring,
            failreason ? failreason : "",
            (/*num_pocketed &&*/ !failreason) ? "\n" : ""
        );
        
        if(!failreason && num_pocketed > 0)
            Winner::Compete(num_pocketed,
                nframes_scoring,
                cand.GetModel());
        fflush(stderr);
        
        scrFinish(0);
    }
    
    typedef CandidateOptMapType i1s;         typedef i1s::iterator i1; // i, preang -> *prevel
    typedef i1::value_type::second_type i2s; typedef i2s::iterator i2; // j, prevel -> *ang
    typedef i2::value_type::second_type i3s; typedef i3s::iterator i3; // k, ang -> *vel
    typedef i3::value_type::second_type i4s; typedef i4s::iterator i4; // l, vel -> *candidate
    typedef i4::value_type::second_type i5s; 
    
    template<typename VelT, typename NextT>
    int RunCandidates_VelocityLoop(VelT& list, NextT& j,
        unsigned& num_pocketed, unsigned& nframes, unsigned& vel)
    {
        using namespace LunarballLaunchManager2ns;
    
        scrBegin;

        /* For each prevelocity / velocity */
        while(!list.empty())
        {
            for(;;)
            {
                vel = RAM[0x3A0];
                j = list.find(vel);
                if(j != list.end()) break;
                if(nframes++ >= MAX_FRAMES) goto Fail;
                RunFrameWith(0x00);
            }
            /* got vel and j */
            /* Shoot */
            static LunarState shot_state; shot_state.Save(num_pocketed,nframes);
            scrReturn(2);
            list.erase(j);
            if(!list.empty()) shot_state.Load();
        }
    Fail: ;
        scrFinish(0);
    }
    
    template<typename AngT, typename NextT>
    int RunCandidates_AngleLoop(AngT& list, NextT& k,
        unsigned& num_pocketed, unsigned& nframes, unsigned& ang)
    {
        using namespace LunarballLaunchManager2ns;
    
        scrBegin;
        
        /* For each preangle / angle. */
        
        /* Divide the angles into groups per what kind of input
         * is needed to create them. After that, for each group,
         * one just need to extend one frame at time until the
         * desired frame is met.
         */
        typedef std::map<unsigned/*angle*/, NextT> AimList;
        typedef std::map<AimingMethod, AimList> AimMap;
        static AimMap aims;
        aims.clear();
        for(k = list.begin(); k != list.end(); ++k)
        {
            AimingMethod method;
            method.Decide(k->first);
            aims[method][k->first] = k;
        }

        static LunarState begin; begin.Save(num_pocketed,nframes);
        
        static typename AimMap::iterator ai;
        for(ai = aims.begin(); ai != aims.end(); ++ai)
        {
            static unsigned aim_framecount; aim_framecount = 0;
            
            if(ai != aims.begin()) begin.Load();
            
            while(!ai->second.empty())
            {
                for(;;)
                {
                    ang = RAM[0x3C0];
                    
                    { typename AimList::iterator j = ai->second.find(ang);
                      if(j != ai->second.end())
                      {
                        k = j->second;
                        ai->second.erase(j);
                        break;
                    } }
                    
                    if(nframes++ >= MAX_FRAMES) goto FailAim;

                    RunFrameWith( (ai->first.autofire && (aim_framecount++&1))
                                 ? 0x00
                                 : ai->first.key );
                }
                /* got ang and k */
                /* Now each velocity for this angle.... */
                static LunarState aim_state; aim_state.Save(num_pocketed,nframes);
                scrReturn(2);
                if(!ai->second.empty()) aim_state.Load();
            }
        FailAim: ;
        }
        scrFinish(0);
    }
    
    /* Actual shot */
    bool RunCandidates_4do(unsigned& num_pocketed, unsigned& nframes,
                           i5s& lsecond, unsigned preang, unsigned prevel,
                           unsigned ang, unsigned vel)
    {
        using namespace LunarballLaunchManager2ns;
    
        scrBegin;
    
        static const char* failreason; failreason = 0;
        
        while(DoProfileShot(num_pocketed, nframes,
                            failreason, MAX_FRAMES)) scrReturn(1);
        if(failreason)
        {
            /*fprintf(stderr, "ang[%3d]vel[%3d]preang[%3u]prevel[%3u]: %s\n",
                ang,vel,preang,prevel,
                failreason);*/
            goto Fail;
        }
        
        while(AnalyzeShotResult(*lsecond, num_pocketed, nframes,
            ang,vel,preang,prevel)) scrReturn(1);
        
    /*EndLoop:*/ Fail: ;
        scrFinish(0);
    }
    
    /* Preshot */
    bool RunCandidates_2do(unsigned& num_pocketed, unsigned& nframes,
                           i3s& jsecond, unsigned preang, unsigned prevel)
    {
        using namespace LunarballLaunchManager2ns;
    
        scrBegin;
        
        static const char* failreason; failreason = 0;
        
        while(DoProfileShot(num_pocketed, nframes,
                            failreason, MAX_FRAMES)) scrReturn(1);
        if(failreason)
        {
            /* Second shot is irrelevant now */
            for(i3 k = jsecond.begin(); k != jsecond.end(); ++k)
                for(i4 l = k->second.begin(); l != k->second.end(); ++l)
                    l->second->dummy_first = true;

            /*fprintf(stderr, "ang[*]vel[*]preang[%3u]prevel[%3u]: %s\n",
                preang,prevel,
                failreason);*/
            goto Fail;
        }
        
        if(num_pocketed > 0)
        {
            /* Second shot is irrelevant now */
            /* Just analyze the shot, put it in one of the candidates
             * and mark all of them as "dummy_first" */
            static bool first; first=true;
            static i3 k;
            static i4 l;
            for(k = jsecond.begin(); k != jsecond.end(); ++k)
                for(l = k->second.begin(); l != k->second.end(); ++l)
                {
                    l->second->dummy_first = true;
                    if(first)
                    {
                        static unsigned ang, vel;
                        ang = k->first;
                        vel = l->first;
                        while(AnalyzeShotResult(*l->second, num_pocketed, nframes,
                            ang,vel,preang,prevel)) scrReturn(1);
                        first = false;
                    }
                }
            goto EndLoop;
        }
        if(!DO_DUALSHOT) goto EndLoop;

        static unsigned nextshot; nextshot = 0;
        
        if(IGNORE_SCORE_DELAYS)
        {
            static unsigned nf1; nf1=0;
            while(DoWaitNextShotPossible(nf1, nextshot,
                false, 9999)) scrReturn(1);
        }
        else
        {
            while(DoWaitNextShotPossible(nframes, nextshot,
                false, MAX_FRAMES)) scrReturn(1);
        }
        // ignore transition time, it shouldn't transition here
        if(nextshot) { failreason="??transition"; goto Fail; }
        
        /* actual shot */
        while(RunCandidates_3(num_pocketed, nframes, jsecond, preang, prevel)) scrReturn(1);
        
    EndLoop: Fail: ;
        scrFinish(0);
    }
    
    /* Velocity loop */
    bool RunCandidates_4(unsigned& num_pocketed, unsigned& nframes,
                         i4s& ksecond, unsigned preang, unsigned prevel, unsigned ang)
    {
        scrBegin;
        for(;;)
        {
            static i4 l;
            static unsigned vel;
            { int c = RunCandidates_VelocityLoop(ksecond, l, num_pocketed, nframes, vel);
              if(!c) break;
              if(c == 1) goto Idle;
            }
            /* got vel and l */
            /* Shoot the shot */
            while(RunCandidates_4do(num_pocketed, nframes, l->second, preang, prevel, ang, vel)) scrReturn(1);
            continue;
        Idle: scrReturn(1);
        }
        scrFinish(0);
    }
    
    /* Angle loop */
    bool RunCandidates_3(unsigned& num_pocketed, unsigned& nframes,
                         i3s& jsecond, unsigned preang, unsigned prevel)
    {
        scrBegin;
        for(;;)
        {
            static i3 k;
            static unsigned ang;
            { int c = RunCandidates_AngleLoop(jsecond, k, num_pocketed, nframes, ang);
              if(!c) break;
              if(c == 1) goto Idle;
            }
            /* got ang and k */
            /* Check each velocity */
            while(RunCandidates_4(num_pocketed, nframes, k->second, preang, prevel, ang)) scrReturn(1);
            continue;
        Idle: scrReturn(1);
        }
        scrFinish(0);
    }

    /* Prevelocity */
    bool RunCandidates_2(unsigned& num_pocketed, unsigned& nframes,
                         i2s& isecond, unsigned preang)
    {
        scrBegin;
        for(;;)
        {
            static i2 j;
            static unsigned prevel;
            { int c = RunCandidates_VelocityLoop(isecond, j, num_pocketed, nframes, prevel);
              if(!c) break;
              if(c == 1) goto Idle;
            }
            /* got prevel and j */
            /* Shoot the preshot -> Check each angle */
            while(RunCandidates_2do(num_pocketed, nframes, j->second, preang, prevel)) scrReturn(1);
            continue;
        Idle: scrReturn(1);
        }
        scrFinish(0);
    }

    /* Preangle */
    bool RunCandidates_1(unsigned& num_pocketed, unsigned& nframes,
                         i1s& optmap)
    {
        scrBegin;
        for(;;)
        {
            static i1 i;
            static unsigned preang;
            { int c = RunCandidates_AngleLoop(optmap, i, num_pocketed, nframes, preang);
              if(!c) break;
              if(c == 1) goto Idle;
            }
            /* got preang and i */
            /* Check each velocity */
            while(RunCandidates_2(num_pocketed, nframes, i->second, preang)) scrReturn(1);
            continue;
        Idle: scrReturn(1);
        }
        scrFinish(0);
    }
    
    bool RunCandidates(const SaveState& itbegin_state, CandidateOptMapType& optmap)
    {
        scrBegin;
        
        itbegin_state.Load();
        
        static unsigned num_pocketed; num_pocketed = 0;
        static unsigned nframes;      nframes      = 0;

        while(RunCandidates_1(num_pocketed, nframes, optmap)) scrReturn(1);
        
        scrFinish(0);
    }
    
    typedef std::deque<CandidateType> CandidateListType;
    
    void WaitCandidate(CandidateListType& CandidateList,
                       std::map<int, unsigned>& pid_list,
                       bool block)
    {
        for(int waitflag = block ? 0 : WNOHANG; ; waitflag = WNOHANG)
        {
            int status = 0;
            int pid = waitpid(-1, &status, waitflag);
            if(pid <= 0) break;
        
            std::map<int, unsigned>::iterator i = pid_list.find(pid);
            if(i == pid_list.end())
            {
                fprintf(stderr, "Unknown child %d died\n", pid);
            }
            else
            {
                const unsigned first_candno = i->second;
                unsigned candno     = first_candno;
                unsigned end_candno = candno + NUM_CANDIDATES_PER_PROCESS;
                if(end_candno > CandidateList.size()) end_candno = CandidateList.size();
                
                for(; candno < end_candno; ++candno)
                {
                    CandidateType* candit = &CandidateList[candno];
                    candit->LoadRes();
                }
                pid_list.erase(i);
            }

            if(WIFSIGNALED(status))
            {
                fprintf(stderr, "Child died at signal %d\n",
                    WTERMSIG(status));
            }
        }
    }
    
    int LaunchNCandidates
        (CandidateListType& CandidateList, const unsigned first_candno,
         std::map<int, unsigned>& pid_list,
         const SaveState& itbegin)
    {
        scrBegin;
        
        if(true) // parent
        {
            Winner::LoadLimit();
        
            int pid;
            fflush(stdout);
            fflush(stderr);
            pid = fork();
            if(pid > 0)
            {
                pid_list[pid] = first_candno;
                fprintf(stderr, "."); fflush(stderr);
                goto end;
            }
            if(pid < 0)
            {
                perror("fork");
                goto end;
            }
        }
        
        // child
        
        MovieForkIntoTempFiles();
        
        static unsigned end_candno;
        end_candno = first_candno + NUM_CANDIDATES_PER_PROCESS;
        if(end_candno > CandidateList.size())
            end_candno = CandidateList.size();
        
        static CandidateOptMapType optmap;
        optmap.clear();
        for(unsigned candno=first_candno; candno < end_candno; ++candno)
        {
            CandidateType* candit = &CandidateList[candno];
            unsigned model = candit->GetModel();
            unsigned cur = model%65536, ang=cur%256, vel=cur/256;
            unsigned pre = model/65536, preang=pre%256, prevel=pre/256;
            optmap[preang][prevel][ang][vel] = candit;
            candit->scoring = 0; // Assume it does really badly
        }
        
        while(RunCandidates(itbegin, optmap)) scrReturn(1);
        optmap.clear();

        for(unsigned candno=first_candno; candno < end_candno; ++candno)
            CandidateList[candno].SaveRes();
        
        // terminate child
        fflush(stdout);
        fflush(stderr);
        _exit(0);
    
    end:;
        scrFinish(0);
    }

    int RunCandidates(CandidateListType& CandidateList,
                      const SaveState& itbegin)
    {
        scrBegin;
        
        static std::map<int, unsigned> pid_list;
        pid_list.clear();
        BotFrontDisableVideo=2;
        
        // Sort the new-round candidates, in an order that
        // is fastest to execute
       // std::sort(CandidateList.begin(), CandidateList.end(),
       //           std::mem_fun_ref(&CandidateType::SimilarityCompare));
        
        /* As much as I'd like to use OpenMP here, it wouldn't work because it's
         * not compatible with coroutines: an omp loop may only have one exit.
         */
        static unsigned candno;
        for(candno=0; candno<CandidateList.size(); candno+=NUM_CANDIDATES_PER_PROCESS)
        {
            do {
                WaitCandidate(CandidateList, pid_list, pid_list.size() >= NUM_FORKS);
            } while(pid_list.size() >= NUM_FORKS);
            
            while(LaunchNCandidates(CandidateList, candno, pid_list, itbegin)) scrReturn(1);
        }
        BotFrontDisableVideo=1;

        while(!pid_list.empty())
        {
            WaitCandidate(CandidateList, pid_list, true);
        }
        
        scrFinish(0);
    }
    
    static void CreateSeedF(
        std::bitset<0x10000>& covered_preshots,
        std::bitset<0x100000000ULL>& covered_candidates,
        CandidateListType& WinnerList,
        unsigned model,
        bool is_oneshot)
    {
        /*if(preang >= 110 && preang < 0x90)*/
        /*if(preang >= 0x75 && ang >= 0x75)*/
        /*if(ang < 40 || ang > 170)*/
        CandidateType tmp;
        if(!covered_preshots[model >> 16]
        && !covered_candidates[model])
        {
            WinnerList.push_back(tmp.SetModel(model, is_oneshot));
            if(is_oneshot) covered_preshots[model >> 16] = true;
            covered_candidates[model] = true;
        }
        /*Winner::SetBest(pok,tim,model);*/
    }
    
    int Run()
    {
        scrBegin;
        
        static CandidateListType WinnerList;
        static std::bitset<0x100000000ULL> covered_candidates;
        static std::bitset<0x10000> covered_preshots;
        
BeginNewShot:
        Winner::SetBest(0,0,0, true);
        
        LunarballLaunchManager2ns::MAX_FRAMES = INIT_MAX_FRAMES;
        LunarballLaunchManager2ns::BALLS_REMAINING = RAM[0x18E];
        
        WinnerList.clear();
        covered_candidates.reset();
        covered_preshots.reset();
        
        /* Append the seed group to this list */
        for(unsigned a=0; a< CandidateType::CountSeeds(); ++a)
            WinnerList.push_back(CandidateType().SetSeed(a));

      #define CreateSeed(pok,tim,ang,vel,preang,prevel, is_oneshot) \
          CreateSeedF(covered_preshots, covered_candidates, WinnerList, \
              (ang+vel*256U) + (preang + prevel*256U)*65536U, is_oneshot);
        
        fprintf(stderr, "Beginning new shot. Table=%u, remaining balls=%u\n",
            RAM[0x187], RAM[0x18E]);

        if(RAM[0x187] == 1 && RAM[0x18E] == 6)
        {
            CreateSeed(4, 488,  228,240, 208,138, false);
        }
        if(RAM[0x187] == 1 && RAM[0x18E] == 2)
        {
            CreateSeed(2, 346,   56,177,  36,0, false);
            CreateSeed(1, 225,   59,174,  35,6, false);
        }
        if(RAM[0x187] == 2 && RAM[0x18E] == 6)
        {
            CreateSeed(4, 550,   51,255,  44, 54, false);
            CreateSeed(3, 378,   97,252, 102, 36, false);
            CreateSeed(1, 127,  245, 60,  33,222, false);
            CreateSeed(1, 156,  246,241, 105,141, true);
            CreateSeed(2, 276,    0,255, 100,144, true);
            CreateSeed(2, 250,    0,255, 161,252, true);
            CreateSeed(2, 245,   46,204,  26, 45, false);
        }
        if(RAM[0x187] == 2 && RAM[0x18E] == 2)
        {
            CreateSeed(1, 286,   0x9D,0x60,0x81,0x99, false);
            CreateSeed(1, 251,  157,189, 34,153, true);
            CreateSeed(2, 420,   0x61,0xCC,0x48,0x30, false);
            CreateSeed(2, 420,   97,204,77,27, false);
            CreateSeed(2, 420,   97,207,77,27, false);
            CreateSeed(2, 422,   97,204,77,33, false);
            CreateSeed(2, 422,   97,207,72,24, false);
            CreateSeed(2, 422,   97,222,72,48, false);
            CreateSeed(2, 422,   97,225,77,21, false);
            
            CreateSeed(2, 430,   97,225,77,42, false);
            CreateSeed(2, 439, 24,177,40,18, false);
            CreateSeed(2, 439, 53,234,13,27, false);
            CreateSeed(2, 439, 98,225,53,27, false);
            CreateSeed(2, 439, 107,210,57,39, false);
            CreateSeed(2, 439, 95,234,97,30, false);
            CreateSeed(2, 464, 102,246,109,33, false);
            CreateSeed(2, 464,  26,225,14,24, false);
        }
        if(RAM[0x187] == 4 && RAM[0x18E] == 5)
        {/*
            CreateSeed(3, 373,  134,  243,  126,  33, false);
            CreateSeed(3, 373,  134,  243,  126,  36, false);
            CreateSeed(3, 373,  134,  243,  126,  48, false);
            CreateSeed(3, 373,  134,  243,  127,  45, false);*/
        }
        if(RAM[0x187] == 5 && RAM[0x18E] == 7)
        {
            CreateSeed(1, 191, 84,255, 84,207, true);
            CreateSeed(2, 301, 80,255, 80,213, true);
            CreateSeed(3, 372, 86,255, 86,255, true);
        }
        if(RAM[0x187] == 5 && RAM[0x18e] == 4)
        {
            CreateSeed(3,534,155,255,155,45,false);
            CreateSeed(3,506,155,255,155,42,false);
            CreateSeed(3,506,155,255,155,39,false);
            CreateSeed(3,506,155,255,155,27,false);
            CreateSeed(1,303,168,255,168,243,false);
            CreateSeed(2,324,170,255,170,249,false);
            CreateSeed(3,446,169,255,169,240,false);
            CreateSeed(1,303,168,255,168,243,false);
            CreateSeed(2,324,170,255,170,249,false);
            CreateSeed(4,696,136,246,76,18,false);
            CreateSeed(4,693,136,240,76,21,false);
            CreateSeed(4,693,136,243,76,21,false);
            CreateSeed(4,693,136,240,76,24,false);
            CreateSeed(4,693,136,243,76,24,false);
            CreateSeed(4,692,136,237,76,45,false);
            CreateSeed(4,641,74,246,81,51,false);
            CreateSeed(4,572,68,240,88,18,false);
            CreateSeed(4,569,68,237,88,21,false);
            CreateSeed(4,568,67,243,93,45,false);
            CreateSeed(4,568,67,246,93,45,false);
            CreateSeed(4,567,67,240,93,51,false);
            CreateSeed(4,553,63,210,95,42,false);
        }
        if(RAM[0x187] == 6 && RAM[0x18E] == 6)
        {
            CreateSeed(0,400,7,255,7,174,false);
            CreateSeed(0,398,7,255,7,168,false);
            CreateSeed(0,373,12,255,12,132,false);
            CreateSeed(0,364,12,255,12,129,false);
            CreateSeed(0,364,12,255,12,126,false);
            CreateSeed(0,302,15,255,15,192,false);
            CreateSeed(0,302,15,255,15,189,false);
            CreateSeed(0,294,15,255,15,174,false);
            CreateSeed(0,422,21,255,21,210,false);
            CreateSeed(0,379,46,255,46,228,false);
            CreateSeed(0,420,40,255,40,255,false);
            CreateSeed(0,273,45,255,45,231,false);
            CreateSeed(0,264,45,255,45,141,false);
            CreateSeed(0,378,47,255,47,228,false);
            CreateSeed(0,298,50,255,50,216,false);
            CreateSeed(0,241,62,255,62,132,false);
            CreateSeed(0,240,62,255,62,117,false);
            CreateSeed(0,132,64,255,64,177,false);
            CreateSeed(0,365,81,255,81,216,false);
            CreateSeed(0,345,81,255,81,243,false);
            CreateSeed(0,291,229,255,229,255,false);
            CreateSeed(0,132,64,255,64,177,false);
            CreateSeed(0,291,229,255,229,255,false);
        }
        if(RAM[0x187] == 7 && RAM[0x18E] == 7)
        {
            CreateSeed(0,0, 45,252, 73,24,false);
            CreateSeed(0,0, 45,255, 73,24,false);
            CreateSeed(0,0, 45,252, 73,27,false);
            CreateSeed(0,0, 45,255, 73,27,false);
            CreateSeed(0,0, 59,234, 56,42,false);
            CreateSeed(0,0, 59,237, 56,42,false);
        }
        if(RAM[0x187] == 7 && RAM[0x18E] == 2)
        {
            CreateSeed(2,325, 30,207,39,30, false);
            CreateSeed(2,325, 30,207,39,33, false);
            CreateSeed(2,325, 30,204,39,45, false);
            CreateSeed(1,154, 48,255,48,240, false);
        }
        if(RAM[0x187] == 8 && RAM[0x18E] == 3)
        {
            CreateSeed(1,125, 50,255,50,171, false);
            CreateSeed(2,203, 33,255,33,234, false);
            CreateSeed(3,389, 15,237,27,24, false);
            CreateSeed(3,389, 15,240,27,33, false);
            CreateSeed(3,389, 15,237,27,33, false);
            CreateSeed(3,389, 15,240,27,36, false);
            CreateSeed(3,389, 15,237,27,36, false);
            CreateSeed(3,389, 15,240,28,21, false);
            CreateSeed(3,389, 15,237,28,33, false);
            CreateSeed(3,389, 15,240,28,33, false);
        }
        if(RAM[0x187] == 9 && RAM[0x18E] == 6)
        {
            CreateSeed(3,263, 7,255, 7,84, false);
            CreateSeed(3,263, 246,240, 10,54, false);
            //CreateSeed(3,250, 64,210, 34,30, false);
        }
        if(RAM[0x187] == 9 && RAM[0x18E] == 3)
        {
            CreateSeed(3,403, 239,237, 13,18, false);
        }
        if(RAM[0x187] == 10 && RAM[0x18E] == 6)
        {
            CreateSeed(3, 316, 231,246, 225,18, false);
            CreateSeed(4, 423, 35,255, 11,48, false);
            CreateSeed(4, 448, 250,246, 6,57, false);
            CreateSeed(4, 447, 250,237, 6,63, false);
        }
        if(RAM[0x187] == 13 && RAM[0x18E] == 7)
        {
            CreateSeed(1, 169, 231,255, 231,75, true);
            CreateSeed(3, 328, 222,237, 21,39, false);
            CreateSeed(2, 254, 7,198, 39,33, false);
            CreateSeed(4, 478, 12,237, 3, 48, false);
            CreateSeed(4, 397, 12,207, 3, 51, false);
            CreateSeed(4, 397, 12,210, 3, 51, false);
        }
        if(RAM[0x187] == 13 && RAM[0x18E] == 3)
        {
            CreateSeed(1, 164, 4,255,4,249, true);
            CreateSeed(2, 254, 10,255,10,216, true);
        }
        if(RAM[0x187] == 14 && RAM[0x18E] == 7)
        {
            CreateSeed(1, 12, 186,255, 186,60, true);
            CreateSeed(2, 294, 197,255, 197,210, false);
            CreateSeed(2, 269, 173,237, 203,36, false);
            CreateSeed(3, 497, 111,237, 71,27, false);
            CreateSeed(3, 370, 199,237, 186,21, false);
            CreateSeed(4, 548, 220,255, 220,96, false);
        }
        if(RAM[0x187] == 16 && RAM[0x18E] == 6)
        {
            CreateSeed(3, 378, 1,213, 21,36, false);
            CreateSeed(2, 316, 59,198, 25,42, false);
            CreateSeed(1, 159, 110,255, 110,177, false);
        }
        if(RAM[0x187] == 23 && RAM[0x18E] == 7)
        {
            CreateSeed(1, 180, 147,255, 147,234, false);
            CreateSeed(2, 277, 222,204, 1,33, false);
            CreateSeed(3, 309, 236,237, 0, 24, false);
            CreateSeed(4, 640, 45,243, 49,57, false);
            CreateSeed(1, 284, 7,255, 7,174, false);
            CreateSeed(2, 284, 55,255, 55,255, false);
            CreateSeed(3, 325,239,255,255,24, false);
            CreateSeed(3, 348,224,237,250,27, false);
            CreateSeed(4, 523,215,240,230,51, false);
            CreateSeed(3,360, 9,252,238,54, false);
            CreateSeed(4,640,45,243,49,57,false);
            CreateSeed(2,277,222,204,1,33,false);
            CreateSeed(2,277,222,201,1,33,false);
            CreateSeed(3,430,0,240,223,57,false);
            CreateSeed(1,180,148,255,148,237,false);
        }
        if(RAM[0x187] == 23 && RAM[0x18E] == 4)
        {
            CreateSeed(2, 313, 185,210,162,42, false);
            CreateSeed(3, 434,84,210,55,39, false);
            CreateSeed(4, 489,84,213,52,21, false);
            CreateSeed(1, 227,1,255,1,150, false);
            CreateSeed(3, 445, 36,240,39,42, false);
            CreateSeed(3, 453,27,255,29,24, false);
            CreateSeed(2, 355,16,255,16,33, false);
            
            CreateSeed(2, 313,185,210,162,42,false);
            CreateSeed(3,434,84,210,55,39, false);
            CreateSeed(2,307,17,207,223,27, false);
            CreateSeed(2,313,17,240,223,24, false);
        }
        if(RAM[0x187] == 24 && (RAM[0x18E] == 7 || RAM[0x18E] == 4 || RAM[0x18E] == 3))
        {
            CreateSeed(2, 235, 142,207, 110,33, false);
            CreateSeed(3, 307, 163,237, 93,39, false);
            CreateSeed(4, 444, 40,255, 86,48, false);
            CreateSeed(1, 194,135,255, 135,141, false);
            CreateSeed(1, 131,163,255, 163,252, false);
            CreateSeed(1, 141,162,255,162,246, false);
            CreateSeed(2, 438, 14,255,14,246, false);
            CreateSeed(2, 240, 145,213,83,21, false);
            CreateSeed(2, 324,44,255,44,183, false);
            CreateSeed(2, 232,143,174,109,18, false);
            CreateSeed(4,436,122,249,79,81, false);
            CreateSeed(3, 303, 161,237,114,24,false);
            CreateSeed(4, 436,122,252,79,60, false);
            CreateSeed(3, 419,239,252,226,21, false);
            CreateSeed(1, 146,168,255,168,213,false);
            CreateSeed(3,449,202,213,126,18, false);
            CreateSeed(3,449,202,213,127,18, false);
            CreateSeed(2,355,171,246,177,45, false);
        }
        if(RAM[0x187] == 25 && RAM[0x18E] == 6)
        {
            CreateSeed(2,226,157,255,157,180, false);
            CreateSeed(2,258,164,255,164,204, false);
            CreateSeed(3,415,25,255,25,252,false);
            CreateSeed(1,162,12,255,12,219,false);
            CreateSeed(3,360,180,243,195,27, false);
            CreateSeed(1,112,201,255,201,141, false);
        }
        if(RAM[0x187] == 25 && RAM[0x18E] == 4)
        {
            CreateSeed(3,387,246,255,219,30, false);
            CreateSeed(3,403,20,240,4,51, false);
            CreateSeed(3,408,0,234,3,45, false);
            CreateSeed(2,375,241,240,0,18,false);
            CreateSeed(1,375,7,255,7,141,false);
            CreateSeed(3,383,246,243,223,18,false);
            CreateSeed(2,342,8,147,6,33, false);
            CreateSeed(2,346,8,162,7,36,false);
            CreateSeed(2,346,3,138,249,24, false);
            CreateSeed(2,346,3,138,249,36, false);
        }
        if(RAM[0x187] == 25 && RAM[0x18E] == 1)
        {
            CreateSeed(1,111,236,255,236,207,false);
            CreateSeed(1,202,234,255,234,174,false);
            CreateSeed(1,233,160,255,160,141,false);
        }
        if(RAM[0x187] == 26 && RAM[0x18E] == 7)
        {
            CreateSeed(3,428,0,237,239,57, false);
            CreateSeed(3,430, 229,234, 238,48, false);
            CreateSeed(2,301,241,255,241,18, false);
            CreateSeed(1,162,1,255,1,174, false);
            CreateSeed(2,299,241,255,243,33,false);
            CreateSeed(1,162,254,255,254,174,false);
            }
        if(RAM[0x187] == 26 && RAM[0x18E] == 4)
        {
            CreateSeed(1,132,0,255,0,243, false);
            CreateSeed(2,366,227,237,241,18,false);
            CreateSeed(2,367,227,243,238,33,false);
        }
        if(RAM[0x187] == 26 && RAM[0x18E] == 3)
        {
            CreateSeed(1,114,249,255,249,219,false);
        }
        if(RAM[0x187] == 26 && RAM[0x18E] == 2)
        {
            CreateSeed(1,184,248,255,248,207,false);
            CreateSeed(2,342,201,255,8,18,false);
        }
        if(RAM[0x187] == 27 && RAM[0x18E] == 7)
        {
            CreateSeed(1,115,0,255,0,144,false);
            CreateSeed(3,315,31,255,31,246,false);
            CreateSeed(4,376,202,255,202,237,false);
        }
        if(RAM[0x187] == 27 && RAM[0x18E] == 3)
        {
            CreateSeed(1,150,190,255,190,201, false);
            CreateSeed(2,345,189,255,189,18,false);
            CreateSeed(3,428,9,240,34,36, false);
            CreateSeed(3,449,6,216,26,51, false);
        }
        if(RAM[0x187] == 28 && RAM[0x18E] == 6)
        {
            CreateSeed(1,372,2,255,2,42, false);
            CreateSeed(2,366,178,255,178,252, false);
            CreateSeed(2,388,6,255,6,66, false);
            CreateSeed(2,388,6,255,6,54, false);
            CreateSeed(3,358,245,207,16,21, false);
            CreateSeed(3,374,178,252,4,36, false);
            CreateSeed(4,439,244,210,17,51, false);
        }
        if(RAM[0x187] == 28 && RAM[0x18E] == 2)
        {
            CreateSeed(1,268,69,255,69,138, false);
            CreateSeed(2,298,13,141,234,24,false);
            CreateSeed(2,297,11,141,236,21,false);
        }
        if(RAM[0x187] == 29 && RAM[0x18E] == 1)
        {
            CreateSeed(1,198,11,255,11,180, false);
        }
        if(RAM[0x187] == 30 && RAM[0x18E] == 6)
        {
            CreateSeed(1,339,16,255,16,42,false);
            CreateSeed(2,306,26,255,26,141,false);
            CreateSeed(2,224,36,255,36,132,false);
            CreateSeed(3,315,226,255,13,21, false);
            CreateSeed(3,311,226,240,13,33, false);
        }
        if(RAM[0x187] == 30 && RAM[0x18E] == 3)
        {
            CreateSeed(1,311,216,255,216,213,false);
            CreateSeed(1,287, 216,255,216,207, false);
            CreateSeed(2,369,220,255,220,237, false);
            CreateSeed(3,419,39,252,26, 18, false);
        } if(RAM[0x187] == 23 && RAM[0x18E] == 7) {
            CreateSeed( 1,668, 7, 255, 7, 156, false);
            CreateSeed( 2,605, 2, 255, 2, 159, false);
            CreateSeed( 1,582, 2, 255, 2, 162, false);
            CreateSeed( 1,284, 7, 255, 7, 171, false);
            CreateSeed( 2,506, 5, 255, 5, 84, false);
            CreateSeed( 1,265, 6, 255, 6, 114, false);
            CreateSeed( 1,265, 6, 255, 6, 117, false);
            CreateSeed( 2,499, 1, 255, 1, 129, false);
            CreateSeed( 2,433, 2, 255, 2, 45, false);
            CreateSeed( 1,224, 13, 255, 13, 18, false);
            CreateSeed( 1,224, 13, 255, 13, 21, false);
            CreateSeed( 1,224, 13, 255, 13, 27, false);
            CreateSeed( 1,224, 13, 255, 13, 30, false);
            CreateSeed( 1,223, 13, 255, 13, 36, false);
            CreateSeed( 1,221, 13, 255, 13, 141, false);
            CreateSeed( 1,220, 13, 255, 13, 174, false);
            CreateSeed( 2,378, 20, 255, 20, 45, false);
            CreateSeed( 3,545, 25, 255, 25, 45, false);
            CreateSeed( 2,373, 22, 255, 22, 33, false);
            CreateSeed( 2,353, 36, 255, 36, 234, false);
            CreateSeed( 2,297, 55, 255, 55, 213, false);
            CreateSeed( 2,284, 55, 255, 55, 252, false);
            CreateSeed( 3,533, 74, 255, 74, 213, false);
            CreateSeed( 1,180, 148, 255, 148, 234, false);
            CreateSeed( 1,180, 147, 255, 147, 234, false);
            CreateSeed( 3,523, 230, 255, 230, 132, false);
            CreateSeed( 3,523, 230, 255, 230, 132, false);
            CreateSeed( 1,180, 147, 255, 147, 234, false);
            CreateSeed( 3,503, 29, 240, 0, 21, false);
            CreateSeed( 3,503, 29, 243, 0, 21, false);
            CreateSeed( 3,323, 236, 207, 0, 24, false);
            CreateSeed( 3,323, 236, 210, 0, 24, false);
            CreateSeed( 3,309, 236, 234, 0, 24, false);
            CreateSeed( 3,309, 236, 237, 0, 24, false);
            CreateSeed( 2,277, 222, 201, 1, 33, false);
            CreateSeed( 2,277, 222, 204, 1, 33, false);
            CreateSeed( 4,640, 45, 240, 49, 57, false);
            CreateSeed( 4,640, 45, 243, 49, 57, false);
        } if(RAM[0x187] == 23 && RAM[0x18E] == 7) {
            CreateSeed( 1,566, 4, 255, 4, 246, false);
            CreateSeed( 2,593, 45, 243, 49, 57, false);
            CreateSeed( 1,559, 2, 255, 2, 138, false);
            CreateSeed( 1,284, 7, 255, 7, 174, false);
            CreateSeed( 2,506, 5, 255, 5, 102, false);
            CreateSeed( 1,264, 6, 255, 6, 111, false);
            CreateSeed( 2,499, 1, 255, 1, 117, false);
            CreateSeed( 2,433, 2, 255, 2, 24, false);
            CreateSeed( 1,223, 13, 255, 13, 21, false);
            CreateSeed( 1,223, 13, 255, 13, 33, false);
            CreateSeed( 1,222, 13, 255, 13, 141, false);
            CreateSeed( 1,220, 13, 255, 13, 174, false);
            CreateSeed( 2,378, 20, 255, 20, 45, false);
            CreateSeed( 3,549, 25, 255, 25, 45, false);
            CreateSeed( 3,545, 25, 255, 25, 48, false);
            CreateSeed( 2,375, 22, 255, 22, 39, false);
            CreateSeed( 2,375, 22, 255, 22, 42, false);
            CreateSeed( 2,366, 36, 255, 36, 207, false);
            CreateSeed( 2,354, 36, 255, 36, 237, false);
            CreateSeed( 2,301, 55, 255, 55, 225, false);
            CreateSeed( 2,284, 55, 255, 55, 255, false);
            CreateSeed( 3,517, 71, 255, 71, 243, false);
            CreateSeed( 1,180, 148, 255, 148, 237, false);
            CreateSeed( 1,180, 148, 255, 148, 237, false);
            CreateSeed( 3,517, 71, 255, 71, 243, false);
            CreateSeed( 4,598, 161, 234, 182, 60, false);
            CreateSeed( 4,598, 161, 237, 182, 60, false);
            CreateSeed( 3,514, 4, 237, 214, 21, false);
            CreateSeed( 3,514, 4, 237, 214, 33, false);
            CreateSeed( 3,514, 4, 237, 214, 45, false);
            CreateSeed( 3,479, 3, 255, 219, 63, false);
            CreateSeed( 3,440, 0, 240, 223, 54, false);
            CreateSeed( 3,440, 0, 243, 223, 54, false);
            CreateSeed( 3,433, 0, 246, 223, 54, false);
            CreateSeed( 3,431, 1, 240, 223, 54, false);
            CreateSeed( 3,430, 0, 240, 223, 57, false);
            CreateSeed( 3,428, 1, 237, 223, 57, false);
            CreateSeed( 3,397, 246, 255, 226, 48, false);
            CreateSeed( 4,523, 215, 240, 230, 51, false);
            CreateSeed( 3,360, 9, 252, 238, 54, false);
            CreateSeed( 3,349, 224, 234, 249, 27, false);
            CreateSeed( 3,348, 224, 237, 249, 27, false);
            CreateSeed( 3,348, 224, 237, 250, 27, false);
            CreateSeed( 3,325, 239, 255, 254, 36, false);
            CreateSeed( 3,325, 239, 255, 255, 24, false);
        } if(RAM[0x187] == 23 && RAM[0x18E] == 4) {
            CreateSeed( 1,275, 2, 255, 2, 147, false);
            CreateSeed( 2,575, 0, 255, 0, 81, false);
            CreateSeed( 2,575, 0, 255, 0, 57, false);
            CreateSeed( 1,227, 1, 255, 1, 150, false);
            CreateSeed( 2,560, 4, 255, 4, 246, false);
            CreateSeed( 2,560, 4, 255, 4, 249, false);
            CreateSeed( 2,552, 11, 255, 11, 18, false);
            CreateSeed( 2,521, 11, 255, 11, 246, false);
            CreateSeed( 2,521, 11, 255, 11, 249, false);
            CreateSeed( 2,357, 16, 255, 16, 51, false);
            CreateSeed( 2,357, 16, 255, 16, 48, false);
            CreateSeed( 2,357, 16, 255, 16, 45, false);
            CreateSeed( 2,355, 16, 255, 16, 42, false);
            CreateSeed( 2,355, 16, 255, 16, 33, false);
            CreateSeed( 3,453, 37, 255, 37, 33, false);
            CreateSeed( 1,227, 1, 255, 1, 150, false);
            CreateSeed( 2,355, 16, 255, 16, 33, false);
            CreateSeed( 2,355, 16, 252, 0, 18, false);
            CreateSeed( 2,355, 16, 255, 0, 18, false);
            CreateSeed( 2,355, 16, 252, 0, 21, false);
            CreateSeed( 2,355, 16, 255, 0, 21, false);
            CreateSeed( 2,355, 16, 255, 0, 27, false);
            CreateSeed( 2,355, 16, 255, 0, 30, false);
            CreateSeed( 2,355, 16, 252, 0, 39, false);
            CreateSeed( 2,355, 16, 255, 0, 39, false);
            CreateSeed( 2,355, 16, 252, 0, 42, false);
            CreateSeed( 2,355, 16, 255, 0, 42, false);
            CreateSeed( 2,350, 16, 234, 1, 18, false);
            CreateSeed( 2,350, 16, 237, 1, 18, false);
            CreateSeed( 2,350, 16, 240, 1, 18, false);
            CreateSeed( 2,350, 16, 234, 1, 30, false);
            CreateSeed( 2,350, 16, 237, 1, 30, false);
            CreateSeed( 2,350, 16, 240, 1, 30, false);
            CreateSeed( 2,350, 16, 240, 2, 18, false);
            CreateSeed( 2,350, 16, 237, 2, 18, false);
            CreateSeed( 2,350, 16, 237, 2, 21, false);
            CreateSeed( 2,350, 16, 240, 2, 21, false);
            CreateSeed( 2,350, 16, 237, 2, 27, false);
            CreateSeed( 2,350, 16, 237, 2, 30, false);
            CreateSeed( 2,350, 16, 234, 2, 42, false);
            CreateSeed( 2,350, 16, 237, 2, 42, false);
            CreateSeed( 2,350, 16, 234, 13, 21, false);
            CreateSeed( 2,350, 16, 237, 13, 21, false);
            CreateSeed( 2,350, 16, 234, 13, 24, false);
            CreateSeed( 2,350, 16, 237, 13, 24, false);
            CreateSeed( 2,350, 16, 237, 13, 27, false);
            CreateSeed( 2,350, 16, 237, 13, 33, false);
            CreateSeed( 2,350, 16, 237, 13, 36, false);
            CreateSeed( 2,350, 16, 237, 13, 42, false);
            CreateSeed( 2,350, 16, 237, 13, 45, false);
            CreateSeed( 2,350, 16, 237, 13, 48, false);
            CreateSeed( 2,350, 16, 237, 14, 24, false);
            CreateSeed( 2,350, 16, 237, 14, 30, false);
            CreateSeed( 2,350, 16, 234, 14, 33, false);
            CreateSeed( 2,350, 16, 234, 14, 36, false);
            CreateSeed( 2,350, 16, 234, 14, 39, false);
            CreateSeed( 2,350, 16, 234, 14, 45, false);
            CreateSeed( 2,350, 16, 237, 14, 45, false);
            CreateSeed( 2,350, 16, 237, 14, 48, false);
            CreateSeed( 2,350, 16, 237, 14, 51, false);
            CreateSeed( 2,350, 16, 237, 19, 18, false);
            CreateSeed( 2,350, 16, 237, 19, 27, false);
            CreateSeed( 2,350, 17, 237, 19, 30, false);
            CreateSeed( 2,350, 16, 234, 19, 39, false);
            CreateSeed( 2,350, 16, 237, 19, 39, false);
            CreateSeed( 2,350, 16, 240, 19, 39, false);
            CreateSeed( 2,350, 17, 237, 19, 42, false);
            CreateSeed( 2,350, 16, 237, 20, 18, false);
            CreateSeed( 2,350, 16, 237, 20, 30, false);
            CreateSeed( 2,350, 16, 237, 20, 39, false);
            CreateSeed( 2,350, 17, 237, 20, 42, false);
            CreateSeed( 2,350, 16, 237, 21, 18, false);
            CreateSeed( 2,350, 16, 237, 21, 27, false);
            CreateSeed( 2,350, 17, 237, 21, 30, false);
            CreateSeed( 2,350, 17, 240, 21, 30, false);
            CreateSeed( 2,350, 16, 237, 21, 42, false);
            CreateSeed( 2,350, 17, 237, 21, 45, false);
            CreateSeed( 2,348, 17, 210, 22, 18, false);
            CreateSeed( 2,348, 17, 213, 22, 18, false);
            CreateSeed( 2,348, 17, 213, 22, 21, false);
            CreateSeed( 2,348, 17, 213, 22, 30, false);
            CreateSeed( 2,348, 17, 213, 23, 18, false);
            CreateSeed( 2,348, 17, 213, 23, 21, false);
            CreateSeed( 2,348, 17, 210, 23, 27, false);
            CreateSeed( 2,348, 17, 213, 23, 27, false);
            CreateSeed( 2,348, 17, 210, 23, 30, false);
            CreateSeed( 2,348, 17, 213, 23, 30, false);
            CreateSeed( 2,348, 17, 213, 23, 39, false);
            CreateSeed( 2,348, 17, 213, 23, 42, false);
            CreateSeed( 2,348, 17, 210, 24, 30, false);
            CreateSeed( 2,348, 17, 210, 25, 39, false);
            CreateSeed( 2,348, 17, 213, 25, 39, false);
            CreateSeed( 2,348, 17, 210, 25, 42, false);
            CreateSeed( 2,348, 17, 213, 25, 42, false);
            CreateSeed( 2,335, 18, 207, 27, 21, false);
            CreateSeed( 2,335, 18, 204, 27, 24, false);
            CreateSeed( 3,453, 37, 255, 27, 24, false);
            CreateSeed( 2,335, 18, 204, 27, 36, false);
            CreateSeed( 2,335, 18, 207, 27, 36, false);
            CreateSeed( 2,335, 18, 204, 27, 51, false);
            CreateSeed( 2,335, 18, 207, 27, 51, false);
            CreateSeed( 2,335, 18, 207, 28, 24, false);
            CreateSeed( 2,335, 18, 207, 28, 36, false);
            CreateSeed( 2,335, 18, 207, 28, 39, false);
            CreateSeed( 2,335, 18, 204, 28, 45, false);
            CreateSeed( 2,335, 18, 204, 28, 48, false);
            CreateSeed( 2,335, 18, 204, 28, 51, false);
            CreateSeed( 2,335, 18, 207, 28, 51, false);
            CreateSeed( 2,335, 18, 204, 29, 24, false);
            CreateSeed( 2,335, 18, 207, 29, 24, false);
            CreateSeed( 3,453, 37, 255, 29, 24, false);
            CreateSeed( 2,335, 18, 204, 29, 36, false);
            CreateSeed( 2,335, 18, 207, 29, 36, false);
            CreateSeed( 2,335, 18, 207, 29, 48, false);
            CreateSeed( 2,335, 18, 204, 29, 51, false);
            CreateSeed( 2,335, 18, 204, 30, 24, false);
            CreateSeed( 2,335, 18, 207, 30, 27, false);
            CreateSeed( 2,335, 18, 204, 30, 36, false);
            CreateSeed( 2,335, 18, 204, 30, 45, false);
            CreateSeed( 2,335, 18, 207, 30, 45, false);
            CreateSeed( 2,335, 18, 204, 30, 48, false);
            CreateSeed( 2,335, 18, 207, 30, 48, false);
            CreateSeed( 3,445, 36, 240, 38, 42, false);
            CreateSeed( 3,445, 36, 240, 39, 42, false);
            CreateSeed( 4,489, 84, 213, 51, 21, false);
            CreateSeed( 3,434, 84, 207, 52, 18, false);
            CreateSeed( 4,489, 84, 213, 52, 21, false);
            CreateSeed( 3,434, 84, 210, 52, 39, false);
            CreateSeed( 3,434, 84, 204, 53, 24, false);
            CreateSeed( 3,434, 84, 207, 53, 24, false);
            CreateSeed( 3,434, 84, 207, 53, 36, false);
            CreateSeed( 3,434, 84, 207, 53, 39, false);
            CreateSeed( 3,434, 84, 204, 54, 27, false);
            CreateSeed( 3,434, 84, 207, 54, 27, false);
            CreateSeed( 3,434, 84, 207, 54, 39, false);
            CreateSeed( 3,434, 84, 204, 55, 24, false);
            CreateSeed( 3,434, 84, 207, 55, 24, false);
            CreateSeed( 3,434, 84, 204, 55, 27, false);
            CreateSeed( 3,434, 84, 207, 55, 27, false);
            CreateSeed( 3,434, 84, 207, 55, 39, false);
            CreateSeed( 3,434, 84, 210, 55, 39, false);
            CreateSeed( 2,320, 185, 237, 158, 39, false);
            CreateSeed( 2,318, 186, 234, 158, 39, false);
            CreateSeed( 2,318, 186, 237, 159, 42, false);
            CreateSeed( 2,313, 185, 204, 160, 39, false);
            CreateSeed( 2,313, 185, 207, 160, 39, false);
            CreateSeed( 2,313, 185, 210, 160, 39, false);
            CreateSeed( 2,313, 185, 207, 161, 27, false);
            CreateSeed( 2,313, 185, 207, 161, 30, false);
            CreateSeed( 2,313, 185, 204, 161, 42, false);
            CreateSeed( 2,313, 185, 207, 161, 42, false);
            CreateSeed( 2,313, 185, 210, 161, 42, false);
            CreateSeed( 2,313, 185, 204, 162, 27, false);
            CreateSeed( 2,313, 185, 207, 162, 27, false);
            CreateSeed( 2,313, 185, 210, 162, 27, false);
            CreateSeed( 2,313, 185, 204, 162, 30, false);
            CreateSeed( 2,313, 185, 207, 162, 30, false);
            CreateSeed( 2,313, 185, 210, 162, 30, false);
            CreateSeed( 2,313, 185, 204, 162, 39, false);
            CreateSeed( 2,313, 185, 207, 162, 39, false);
            CreateSeed( 2,313, 185, 210, 162, 39, false);
            CreateSeed( 2,313, 185, 204, 162, 42, false);
            CreateSeed( 2,313, 185, 207, 162, 42, false);
            CreateSeed( 2,313, 185, 210, 162, 42, false);
        } if(RAM[0x187] == 23 && RAM[0x18E] == 4) {
            CreateSeed( 1,211, 2, 255, 2, 150, false);
            CreateSeed( 2,314, 185, 210, 162, 42, false);
            CreateSeed( 4,490, 84, 213, 52, 21, false);
            CreateSeed( 3,435, 84, 210, 55, 39, false);
            CreateSeed( 2,314, 185, 210, 162, 42, false);
            CreateSeed( 1,211, 2, 255, 2, 150, false);
            CreateSeed( 3,435, 84, 210, 55, 39, false);
        } if(RAM[0x187] == 23 && RAM[0x18E] == 4) {
            CreateSeed( 1,211, 2, 255, 2, 150, false);
            CreateSeed( 2,314, 185, 210, 162, 42, false);
            CreateSeed( 4,490, 84, 213, 52, 21, false);
            CreateSeed( 3,435, 84, 210, 55, 39, false);
            CreateSeed( 2,314, 185, 210, 162, 42, false);
            CreateSeed( 1,211, 2, 255, 2, 150, false);
            CreateSeed( 3,435, 84, 210, 55, 39, false);
            CreateSeed( 3,391, 218, 240, 203, 24, false);
            CreateSeed( 3,391, 218, 243, 203, 24, false);
            CreateSeed( 3,389, 218, 234, 203, 36, false);
            CreateSeed( 3,389, 218, 237, 203, 36, false);
            CreateSeed( 3,389, 218, 234, 203, 48, false);
            CreateSeed( 3,389, 218, 237, 203, 48, false);
            CreateSeed( 3,389, 218, 234, 204, 27, false);
            CreateSeed( 3,389, 218, 237, 204, 27, false);
            CreateSeed( 3,389, 218, 234, 204, 33, false);
            CreateSeed( 3,389, 218, 237, 204, 36, false);
            CreateSeed( 3,389, 218, 234, 204, 48, false);
            CreateSeed( 3,389, 218, 237, 204, 48, false);
            CreateSeed( 3,389, 218, 237, 205, 21, false);
            CreateSeed( 3,389, 218, 237, 205, 24, false);
            CreateSeed( 3,389, 218, 234, 205, 36, false);
            CreateSeed( 3,389, 218, 237, 205, 36, false);
            CreateSeed( 3,389, 218, 234, 205, 45, false);
            CreateSeed( 3,389, 218, 237, 205, 48, false);
            CreateSeed( 3,389, 218, 237, 205, 51, false);
            CreateSeed( 3,389, 218, 234, 206, 27, false);
            CreateSeed( 3,389, 218, 237, 206, 27, false);
            CreateSeed( 3,389, 218, 234, 206, 39, false);
            CreateSeed( 3,389, 218, 237, 206, 48, false);
            CreateSeed( 3,389, 218, 237, 207, 24, false);
            CreateSeed( 3,389, 218, 234, 207, 36, false);
            CreateSeed( 3,389, 218, 234, 207, 51, false);
            CreateSeed( 3,389, 218, 237, 207, 51, false);
            CreateSeed( 2,313, 17, 234, 223, 18, false);
            CreateSeed( 2,313, 17, 237, 223, 18, false);
            CreateSeed( 2,313, 17, 234, 223, 21, false);
            CreateSeed( 2,313, 17, 237, 223, 21, false);
            CreateSeed( 2,313, 17, 216, 223, 24, false);
            CreateSeed( 2,313, 17, 219, 223, 24, false);
            CreateSeed( 2,313, 17, 234, 223, 24, false);
            CreateSeed( 2,313, 17, 237, 223, 24, false);
            CreateSeed( 2,313, 17, 240, 223, 24, false);
            CreateSeed( 2,307, 17, 204, 223, 27, false);
            CreateSeed( 2,307, 17, 207, 223, 27, false);
            CreateSeed( 4,490, 84, 213, 51, 21, false);
            CreateSeed( 2,307, 17, 204, 222, 24, false);
        } if(RAM[0x187] == 24 && RAM[0x18E] == 7) {
            CreateSeed( 1,304, 9, 255, 9, 159, false);
            CreateSeed( 1,302, 9, 255, 9, 204, false);
            CreateSeed( 2,548, 8, 255, 8, 243, false);
            CreateSeed( 2,482, 11, 255, 11, 234, false);
            CreateSeed( 2,472, 11, 255, 11, 243, false);
            CreateSeed( 1,252, 10, 255, 10, 159, false);
            CreateSeed( 1,251, 10, 255, 10, 174, false);
            CreateSeed( 1,251, 10, 255, 10, 177, false);
            CreateSeed( 2,376, 27, 255, 27, 216, false);
            CreateSeed( 2,336, 34, 255, 34, 180, false);
            CreateSeed( 1,195, 33, 255, 33, 114, false);
            CreateSeed( 2,324, 44, 255, 44, 183, false);
            CreateSeed( 3,614, 49, 255, 49, 198, false);
            CreateSeed( 3,501, 62, 255, 62, 27, false);
            CreateSeed( 2,273, 74, 255, 74, 42, false);
            CreateSeed( 2,273, 74, 255, 74, 36, false);
            CreateSeed( 2,273, 74, 255, 74, 24, false);
            CreateSeed( 2,267, 74, 255, 74, 255, false);
            CreateSeed( 3,466, 85, 255, 85, 180, false);
            CreateSeed( 1,195, 135, 255, 135, 111, false);
            CreateSeed( 1,194, 135, 255, 135, 141, false);
            CreateSeed( 3,404, 145, 255, 145, 237, false);
            CreateSeed( 3,391, 147, 255, 147, 237, false);
            CreateSeed( 3,389, 146, 255, 146, 234, false);
            CreateSeed( 3,336, 148, 255, 148, 174, false);
            CreateSeed( 1,184, 155, 255, 155, 147, false);
            CreateSeed( 2,267, 74, 255, 74, 255, false);
            CreateSeed( 1,184, 155, 255, 155, 147, false);
            CreateSeed( 4,639, 194, 240, 4, 27, false);
            CreateSeed( 4,639, 194, 243, 4, 27, false);
            CreateSeed( 4,639, 194, 240, 4, 30, false);
            CreateSeed( 4,639, 194, 243, 4, 30, false);
            CreateSeed( 4,636, 194, 234, 4, 36, false);
            CreateSeed( 4,636, 194, 237, 4, 36, false);
            CreateSeed( 4,623, 40, 252, 44, 57, false);
            CreateSeed( 4,555, 50, 210, 46, 54, false);
            CreateSeed( 4,555, 50, 210, 47, 48, false);
            CreateSeed( 4,555, 50, 210, 47, 57, false);
            CreateSeed( 4,555, 50, 213, 47, 57, false);
            CreateSeed( 4,462, 24, 240, 48, 42, false);
            CreateSeed( 4,462, 24, 243, 48, 42, false);
            CreateSeed( 4,461, 24, 234, 48, 54, false);
            CreateSeed( 4,461, 24, 237, 48, 54, false);
            CreateSeed( 3,331, 88, 237, 50, 39, false);
            CreateSeed( 2,257, 43, 234, 56, 24, false);
            CreateSeed( 2,257, 43, 237, 56, 24, false);
            CreateSeed( 2,257, 43, 234, 56, 36, false);
            CreateSeed( 2,257, 43, 237, 56, 36, false);
            CreateSeed( 2,257, 43, 234, 57, 21, false);
            CreateSeed( 2,257, 43, 234, 57, 33, false);
            CreateSeed( 2,257, 43, 237, 58, 24, false);
            CreateSeed( 2,257, 43, 234, 58, 33, false);
            CreateSeed( 2,255, 43, 204, 59, 24, false);
            CreateSeed( 2,255, 43, 207, 59, 36, false);
            CreateSeed( 2,255, 43, 204, 60, 24, false);
            CreateSeed( 2,240, 145, 213, 83, 21, false);
            CreateSeed( 4,444, 40, 255, 86, 36, false);
            CreateSeed( 4,444, 40, 255, 86, 48, false);
            CreateSeed( 3,310, 163, 240, 93, 27, false);
            CreateSeed( 3,307, 163, 237, 93, 39, false);
            CreateSeed( 2,236, 145, 204, 95, 27, false);
            CreateSeed( 2,236, 145, 207, 95, 27, false);
            CreateSeed( 2,236, 143, 204, 105, 36, false);
            CreateSeed( 2,235, 143, 204, 110, 21, false);
            CreateSeed( 2,235, 143, 207, 110, 21, false);
            CreateSeed( 2,235, 143, 204, 110, 33, false);
            CreateSeed( 2,235, 143, 207, 110, 33, false);
        } if(RAM[0x187] == 24 && RAM[0x18E] == 7) {
            CreateSeed( 1,307, 9, 255, 9, 159, false);
            CreateSeed( 1,303, 9, 255, 9, 210, false);
            CreateSeed( 2,548, 8, 255, 8, 243, false);
            CreateSeed( 1,194, 135, 255, 135, 141, false);
            CreateSeed( 2,482, 11, 255, 11, 234, false);
            CreateSeed( 3,391, 40, 255, 86, 48, false);
            CreateSeed( 2,472, 11, 255, 11, 246, false);
            CreateSeed( 4,646, 25, 255, 25, 150, false);
            CreateSeed( 4,646, 25, 255, 25, 159, false);
            CreateSeed( 2,376, 27, 255, 27, 216, false);
            CreateSeed( 2,336, 34, 255, 34, 180, false);
            CreateSeed( 2,324, 44, 255, 44, 183, false);
        } if(RAM[0x187] == 24 && RAM[0x18E] == 7) {
            CreateSeed( 1,307, 9, 255, 9, 159, false);
            CreateSeed( 1,303, 9, 255, 9, 210, false);
            CreateSeed( 1,194, 135, 255, 135, 141, false);
            CreateSeed( 3,391, 40, 255, 86, 48, false);
            CreateSeed( 2,376, 27, 255, 27, 216, false);
            CreateSeed( 2,336, 34, 255, 34, 180, false);
            CreateSeed( 2,324, 44, 255, 44, 183, false);
            CreateSeed( 2,273, 74, 255, 74, 48, false);
            CreateSeed( 2,273, 74, 255, 74, 27, false);
            CreateSeed( 3,336, 148, 255, 148, 177, false);
            CreateSeed( 1,194, 154, 255, 154, 144, false);
            CreateSeed( 1,194, 154, 255, 154, 147, false);
            CreateSeed( 1,184, 155, 255, 155, 147, false);
            CreateSeed( 2,273, 74, 255, 74, 27, false);
            CreateSeed( 1,184, 155, 255, 155, 147, false);
            CreateSeed( 3,335, 88, 252, 50, 39, false);
            CreateSeed( 2,257, 43, 234, 56, 24, false);
            CreateSeed( 2,257, 43, 234, 57, 24, false);
            CreateSeed( 2,257, 43, 237, 57, 24, false);
            CreateSeed( 2,257, 43, 234, 57, 36, false);
            CreateSeed( 2,257, 43, 237, 57, 36, false);
            CreateSeed( 2,257, 43, 234, 58, 36, false);
            CreateSeed( 2,257, 43, 237, 58, 36, false);
            CreateSeed( 2,255, 43, 204, 59, 21, false);
            CreateSeed( 2,255, 43, 207, 59, 21, false);
            CreateSeed( 2,255, 43, 204, 60, 36, false);
            CreateSeed( 2,255, 43, 207, 60, 36, false);
            CreateSeed( 4,436, 122, 252, 79, 60, false);
            CreateSeed( 2,240, 145, 213, 83, 21, false);
            CreateSeed( 2,240, 145, 210, 83, 45, false);
            CreateSeed( 3,307, 163, 237, 93, 24, false);
            CreateSeed( 2,236, 145, 204, 95, 24, false);
            CreateSeed( 2,236, 145, 207, 95, 36, false);
            CreateSeed( 2,236, 143, 204, 105, 24, false);
            CreateSeed( 2,235, 143, 207, 109, 33, false);
            CreateSeed( 2,235, 143, 204, 110, 33, false);
            CreateSeed( 2,235, 143, 204, 111, 21, false);
            CreateSeed( 3,303, 161, 237, 115, 36, false);
            CreateSeed( 3,303, 161, 237, 114, 36, false);
            CreateSeed( 2,232, 143, 177, 111, 21, false);
            CreateSeed( 3,303, 161, 237, 114, 24, false);
            CreateSeed( 2,232, 143, 171, 111, 18, false);
            CreateSeed( 4,436, 122, 252, 79, 81, false);
            CreateSeed( 2,232, 143, 174, 111, 18, false);
            CreateSeed( 2,232, 143, 174, 111, 21, false);
            CreateSeed( 4,436, 122, 249, 79, 81, false);
            CreateSeed( 2,232, 143, 174, 111, 24, false);
            CreateSeed( 2,232, 143, 174, 109, 18, false);
        } if(RAM[0x187] == 24 && RAM[0x18E] == 4) {
            CreateSeed( 1,400, 10, 255, 10, 138, false);
            CreateSeed( 2,438, 14, 255, 14, 246, false);
            CreateSeed( 1,369, 22, 255, 22, 141, false);
            CreateSeed( 1,347, 33, 255, 33, 207, false);
            CreateSeed( 1,343, 33, 255, 33, 240, false);
            CreateSeed( 1,343, 33, 255, 33, 243, false);
            CreateSeed( 1,331, 94, 255, 94, 24, false);
            CreateSeed( 1,331, 94, 255, 94, 21, false);
            CreateSeed( 1,329, 94, 255, 94, 18, false);
            CreateSeed( 1,329, 94, 255, 94, 36, false);
            CreateSeed( 1,329, 94, 255, 94, 39, false);
            CreateSeed( 1,308, 94, 255, 94, 171, false);
            CreateSeed( 1,308, 94, 255, 94, 174, false);
            CreateSeed( 1,297, 94, 255, 94, 237, false);
            CreateSeed( 1,211, 108, 255, 108, 66, false);
            CreateSeed( 1,211, 108, 255, 108, 63, false);
            CreateSeed( 1,211, 108, 255, 108, 60, false);
            CreateSeed( 1,157, 149, 255, 149, 201, false);
            CreateSeed( 1,157, 149, 255, 149, 198, false);
            CreateSeed( 1,155, 149, 255, 149, 177, false);
            CreateSeed( 1,155, 149, 255, 149, 174, false);
            CreateSeed( 1,152, 149, 255, 149, 138, false);
            CreateSeed( 1,152, 149, 255, 149, 135, false);
            CreateSeed( 2,331, 159, 255, 159, 255, false);
            CreateSeed( 1,141, 162, 255, 162, 246, false);
            CreateSeed( 1,131, 163, 255, 163, 252, false);
            CreateSeed( 2,331, 159, 255, 159, 255, false);
            CreateSeed( 3,434, 161, 237, 95, 21, false);
            CreateSeed( 3,434, 161, 240, 95, 21, false);
            CreateSeed( 3,434, 161, 237, 95, 24, false);
            CreateSeed( 3,434, 161, 240, 95, 24, false);
            CreateSeed( 3,432, 161, 237, 95, 27, false);
            CreateSeed( 3,432, 161, 240, 95, 27, false);
            CreateSeed( 3,432, 161, 243, 111, 18, false);
            CreateSeed( 3,431, 161, 234, 111, 21, false);
            CreateSeed( 3,431, 161, 237, 111, 21, false);
            CreateSeed( 3,431, 161, 237, 111, 24, false);
            CreateSeed( 3,430, 161, 234, 111, 30, false);
            CreateSeed( 3,430, 161, 237, 111, 30, false);
            CreateSeed( 3,430, 161, 234, 111, 39, false);
            CreateSeed( 3,430, 161, 237, 111, 39, false);
            CreateSeed( 3,430, 161, 234, 112, 30, false);
            CreateSeed( 3,430, 161, 237, 112, 30, false);
            CreateSeed( 3,430, 160, 237, 117, 30, false);
            CreateSeed( 3,430, 160, 240, 117, 30, false);
            CreateSeed( 3,430, 160, 237, 117, 33, false);
            CreateSeed( 3,430, 160, 240, 117, 33, false);
            CreateSeed( 3,429, 159, 234, 119, 18, false);
            CreateSeed( 3,429, 159, 234, 119, 21, false);
            CreateSeed( 3,429, 159, 234, 119, 27, false);
            CreateSeed( 3,429, 159, 237, 119, 27, false);
            CreateSeed( 3,429, 159, 234, 119, 30, false);
            CreateSeed( 3,429, 159, 237, 119, 30, false);
            CreateSeed( 3,429, 159, 234, 119, 42, false);
            CreateSeed( 3,429, 159, 237, 121, 18, false);
            CreateSeed( 3,429, 159, 237, 121, 33, false);
            CreateSeed( 3,429, 159, 237, 121, 45, false);
            CreateSeed( 3,429, 159, 237, 139, 30, false);
            CreateSeed( 3,429, 159, 237, 139, 33, false);
            CreateSeed( 3,429, 159, 234, 139, 42, false);
            CreateSeed( 3,429, 159, 237, 139, 42, false);
            CreateSeed( 3,429, 159, 234, 140, 30, false);
            CreateSeed( 3,429, 159, 237, 140, 30, false);
            CreateSeed( 3,429, 159, 234, 140, 33, false);
            CreateSeed( 3,429, 159, 237, 140, 33, false);
            CreateSeed( 3,429, 159, 234, 141, 30, false);
            CreateSeed( 3,429, 159, 237, 141, 30, false);
            CreateSeed( 3,429, 160, 234, 146, 30, false);
            CreateSeed( 3,429, 160, 237, 146, 30, false);
            CreateSeed( 3,429, 160, 234, 146, 33, false);
            CreateSeed( 3,429, 160, 237, 146, 33, false);
            CreateSeed( 3,429, 160, 234, 146, 42, false);
            CreateSeed( 3,429, 160, 237, 146, 42, false);
            CreateSeed( 3,429, 160, 234, 146, 45, false);
            CreateSeed( 3,429, 160, 237, 146, 45, false);
            CreateSeed( 3,429, 160, 234, 147, 30, false);
            CreateSeed( 3,429, 160, 237, 147, 30, false);
            CreateSeed( 3,429, 160, 234, 147, 33, false);
            CreateSeed( 3,429, 160, 237, 147, 33, false);
            CreateSeed( 3,419, 239, 240, 196, 21, false);
            CreateSeed( 3,419, 239, 237, 196, 36, false);
            CreateSeed( 3,419, 239, 240, 196, 36, false);
            CreateSeed( 3,419, 239, 237, 196, 45, false);
            CreateSeed( 3,419, 239, 237, 196, 48, false);
            CreateSeed( 3,419, 239, 240, 196, 48, false);
            CreateSeed( 3,419, 239, 255, 225, 18, false);
            CreateSeed( 3,419, 239, 255, 225, 21, false);
            CreateSeed( 3,419, 239, 255, 225, 39, false);
            CreateSeed( 3,419, 239, 252, 226, 18, false);
            CreateSeed( 3,419, 239, 252, 226, 21, false);
        } if(RAM[0x187] == 24 && RAM[0x18E] == 3) {
            CreateSeed( 1,433, 63, 255, 63, 117, false);
            CreateSeed( 1,384, 73, 255, 73, 141, false);
            CreateSeed( 2,436, 96, 255, 96, 21, false);
            CreateSeed( 1,370, 91, 255, 91, 138, false);
            CreateSeed( 1,370, 91, 255, 91, 141, false);
            CreateSeed( 1,341, 87, 255, 87, 171, false);
            CreateSeed( 2,367, 102, 255, 102, 27, false);
            CreateSeed( 2,367, 102, 255, 102, 24, false);
            CreateSeed( 1,323, 90, 255, 90, 18, false);
            CreateSeed( 1,323, 90, 255, 90, 21, false);
            CreateSeed( 1,323, 90, 255, 90, 27, false);
            CreateSeed( 1,323, 90, 255, 90, 30, false);
            CreateSeed( 1,323, 90, 255, 90, 33, false);
            CreateSeed( 1,323, 90, 255, 90, 39, false);
            CreateSeed( 1,284, 90, 255, 90, 237, false);
            CreateSeed( 1,284, 90, 255, 90, 240, false);
            CreateSeed( 2,359, 102, 255, 102, 237, false);
            CreateSeed( 1,146, 168, 255, 168, 216, false);
            CreateSeed( 1,146, 168, 255, 168, 213, false);
            CreateSeed( 2,359, 102, 255, 102, 237, false);
            CreateSeed( 2,357, 66, 210, 80, 36, false);
            CreateSeed( 2,357, 66, 213, 80, 36, false);
            CreateSeed( 2,357, 66, 210, 80, 39, false);
            CreateSeed( 2,357, 66, 213, 80, 39, false);
            CreateSeed( 2,357, 66, 213, 81, 39, false);
            CreateSeed( 2,357, 66, 210, 82, 36, false);
            CreateSeed( 2,357, 107, 234, 91, 21, false);
            CreateSeed( 2,357, 107, 237, 91, 21, false);
            CreateSeed( 2,357, 108, 234, 91, 24, false);
            CreateSeed( 2,357, 108, 237, 91, 24, false);
            CreateSeed( 2,357, 108, 234, 91, 27, false);
            CreateSeed( 2,357, 108, 237, 91, 27, false);
            CreateSeed( 2,357, 108, 237, 91, 33, false);
            CreateSeed( 2,357, 107, 237, 91, 33, false);
            CreateSeed( 2,357, 107, 234, 92, 21, false);
            CreateSeed( 2,357, 107, 237, 92, 21, false);
            CreateSeed( 2,357, 108, 234, 92, 21, false);
            CreateSeed( 2,357, 108, 237, 92, 21, false);
            CreateSeed( 2,357, 108, 234, 92, 24, false);
            CreateSeed( 2,357, 108, 237, 92, 24, false);
            CreateSeed( 2,357, 108, 234, 92, 27, false);
            CreateSeed( 2,357, 108, 237, 92, 27, false);
            CreateSeed( 2,357, 108, 234, 92, 33, false);
            CreateSeed( 2,357, 108, 237, 92, 33, false);
            CreateSeed( 2,357, 108, 234, 92, 36, false);
            CreateSeed( 2,357, 108, 237, 92, 36, false);
            CreateSeed( 2,357, 108, 237, 93, 24, false);
            CreateSeed( 2,357, 107, 237, 93, 33, false);
            CreateSeed( 2,357, 108, 237, 94, 24, false);
            CreateSeed( 2,357, 107, 237, 94, 36, false);
            CreateSeed( 2,357, 105, 234, 95, 33, false);
            CreateSeed( 2,357, 106, 237, 95, 33, false);
            CreateSeed( 2,357, 105, 234, 95, 36, false);
            CreateSeed( 2,357, 106, 237, 95, 36, false);
            CreateSeed( 2,357, 106, 237, 96, 21, false);
            CreateSeed( 2,357, 105, 234, 96, 21, false);
            CreateSeed( 2,357, 105, 237, 96, 24, false);
            CreateSeed( 2,357, 106, 234, 96, 24, false);
            CreateSeed( 2,357, 106, 237, 96, 24, false);
            CreateSeed( 2,357, 105, 237, 96, 33, false);
            CreateSeed( 2,357, 106, 234, 96, 36, false);
            CreateSeed( 2,357, 106, 237, 96, 36, false);
            CreateSeed( 2,357, 105, 237, 96, 36, false);
            CreateSeed( 2,357, 106, 237, 97, 24, false);
            CreateSeed( 2,357, 105, 237, 97, 24, false);
            CreateSeed( 2,357, 105, 234, 97, 36, false);
            CreateSeed( 2,357, 106, 234, 97, 36, false);
            CreateSeed( 2,357, 105, 234, 98, 21, false);
            CreateSeed( 3,449, 202, 213, 126, 18, false);
            CreateSeed( 2,355, 171, 246, 176, 42, false);
            CreateSeed( 2,355, 171, 246, 176, 45, false);
            CreateSeed( 2,355, 171, 243, 177, 18, false);
            CreateSeed( 2,355, 171, 243, 177, 21, false);
            CreateSeed( 2,355, 171, 246, 177, 30, false);
            CreateSeed( 2,355, 171, 246, 177, 33, false);
            CreateSeed( 2,355, 171, 246, 177, 42, false);
            CreateSeed( 2,355, 171, 246, 177, 45, false);
            CreateSeed( 3,449, 202, 213, 127, 18, false);
        } if(RAM[0x187] == 25 && RAM[0x18E] == 6) {
            CreateSeed( 1,207, 5, 255, 5, 198, false);
            CreateSeed( 1,203, 3, 255, 3, 192, false);
            CreateSeed( 1,162, 12, 255, 12, 219, false);
            CreateSeed( 2,407, 15, 255, 15, 240, false);
            CreateSeed( 2,291, 25, 255, 25, 255, false);
            CreateSeed( 3,415, 25, 255, 25, 252, false);
            CreateSeed( 2,287, 31, 255, 31, 207, false);
            CreateSeed( 2,258, 164, 255, 164, 204, false);
            CreateSeed( 2,226, 157, 255, 157, 180, false);
            CreateSeed( 1,152, 168, 255, 168, 141, false);
            CreateSeed( 1,150, 167, 255, 167, 138, false);
            CreateSeed( 1,150, 167, 255, 167, 141, false);
            CreateSeed( 1,150, 167, 255, 167, 171, false);
            CreateSeed( 1,144, 173, 255, 173, 108, false);
            CreateSeed( 1,130, 173, 255, 173, 111, false);
            CreateSeed( 1,127, 201, 255, 201, 78, false);
            CreateSeed( 1,113, 201, 255, 201, 108, false);
            CreateSeed( 1,112, 201, 255, 201, 141, false);
            CreateSeed( 1,112, 201, 255, 201, 141, false);
            CreateSeed( 3,415, 25, 255, 25, 252, false);
            CreateSeed( 3,414, 177, 252, 191, 39, false);
            CreateSeed( 3,414, 177, 255, 191, 39, false);
            CreateSeed( 3,381, 180, 243, 191, 39, false);
            CreateSeed( 3,381, 180, 246, 191, 39, false);
            CreateSeed( 3,377, 177, 234, 192, 33, false);
            CreateSeed( 3,377, 177, 237, 192, 33, false);
            CreateSeed( 3,360, 180, 240, 192, 36, false);
            CreateSeed( 3,360, 180, 237, 193, 39, false);
            CreateSeed( 3,360, 180, 240, 193, 39, false);
            CreateSeed( 3,360, 180, 240, 194, 27, false);
            CreateSeed( 3,360, 180, 237, 194, 39, false);
            CreateSeed( 3,360, 180, 240, 194, 39, false);
            CreateSeed( 3,360, 180, 243, 194, 39, false);
            CreateSeed( 3,360, 180, 240, 195, 27, false);
            CreateSeed( 3,360, 180, 243, 195, 27, false);
        } if(RAM[0x187] == 25 && RAM[0x18E] == 4) {
            CreateSeed( 1,375, 7, 255, 7, 141, false);
            CreateSeed( 2,438, 3, 255, 3, 54, false);
            CreateSeed( 2,408, 4, 255, 4, 27, false);
            CreateSeed( 1,371, 4, 255, 4, 180, false);
            CreateSeed( 1,371, 4, 255, 4, 183, false);
            CreateSeed( 1,307, 10, 255, 10, 111, false);
            CreateSeed( 2,404, 12, 255, 12, 237, false);
            CreateSeed( 1,304, 24, 255, 24, 111, false);
            CreateSeed( 1,304, 24, 255, 24, 114, false);
            CreateSeed( 1,288, 24, 255, 24, 147, false);
            CreateSeed( 1,288, 24, 255, 24, 150, false);
            CreateSeed( 1,221, 150, 255, 150, 228, false);
            CreateSeed( 1,212, 150, 255, 150, 231, false);
            CreateSeed( 1,212, 150, 255, 150, 234, false);
            CreateSeed( 2,384, 241, 255, 241, 21, false);
            CreateSeed( 2,384, 241, 255, 241, 18, false);
            CreateSeed( 1,212, 150, 255, 150, 234, false);
            CreateSeed( 2,375, 241, 234, 0, 18, false);
            CreateSeed( 2,375, 241, 237, 0, 18, false);
            CreateSeed( 2,375, 241, 240, 0, 18, false);
            CreateSeed( 3,447, 43, 237, 0, 21, false);
            CreateSeed( 2,374, 43, 237, 0, 24, false);
            CreateSeed( 2,374, 43, 237, 0, 27, false);
            CreateSeed( 2,374, 43, 237, 0, 36, false);
            CreateSeed( 2,374, 43, 240, 0, 36, false);
            CreateSeed( 3,438, 210, 234, 0, 45, false);
            CreateSeed( 3,438, 210, 237, 0, 45, false);
            CreateSeed( 2,373, 14, 237, 3, 24, false);
            CreateSeed( 2,363, 26, 255, 3, 24, false);
            CreateSeed( 2,363, 26, 252, 3, 33, false);
            CreateSeed( 3,408, 0, 234, 3, 45, false);
            CreateSeed( 3,408, 0, 237, 3, 45, false);
            CreateSeed( 2,363, 26, 255, 4, 27, false);
            CreateSeed( 2,363, 26, 252, 4, 30, false);
            CreateSeed( 2,363, 26, 252, 4, 33, false);
            CreateSeed( 3,404, 20, 234, 4, 51, false);
            CreateSeed( 3,404, 20, 237, 4, 51, false);
            CreateSeed( 3,403, 20, 240, 4, 51, false);
            CreateSeed( 2,363, 26, 252, 5, 33, false);
            CreateSeed( 2,363, 26, 255, 5, 33, false);
            CreateSeed( 2,363, 26, 252, 5, 36, false);
            CreateSeed( 2,363, 26, 255, 5, 36, false);
            CreateSeed( 2,363, 26, 255, 5, 39, false);
            CreateSeed( 2,359, 20, 219, 210, 27, false);
            CreateSeed( 2,358, 20, 213, 214, 21, false);
            CreateSeed( 2,358, 20, 213, 214, 24, false);
            CreateSeed( 2,355, 20, 210, 214, 27, false);
            CreateSeed( 2,355, 20, 210, 214, 30, false);
            CreateSeed( 2,355, 20, 210, 214, 39, false);
            CreateSeed( 2,355, 20, 210, 214, 42, false);
            CreateSeed( 3,387, 246, 255, 219, 30, false);
            CreateSeed( 3,383, 246, 243, 221, 18, false);
            CreateSeed( 3,383, 246, 243, 223, 18, false);
            CreateSeed( 2,354, 4, 204, 226, 33, false);
            CreateSeed( 2,354, 4, 204, 227, 30, false);
            CreateSeed( 2,354, 4, 207, 228, 33, false);
            CreateSeed( 2,354, 4, 204, 229, 30, false);
            CreateSeed( 2,354, 4, 207, 229, 30, false);
            CreateSeed( 2,351, 4, 207, 246, 27, false);
            CreateSeed( 2,351, 4, 207, 246, 30, false);
            CreateSeed( 2,351, 4, 204, 246, 39, false);
            CreateSeed( 2,351, 4, 207, 246, 39, false);
            CreateSeed( 2,351, 4, 204, 246, 42, false);
            CreateSeed( 2,351, 4, 207, 246, 42, false);
            CreateSeed( 2,351, 4, 207, 247, 18, false);
            CreateSeed( 2,351, 4, 207, 247, 27, false);
            CreateSeed( 2,351, 4, 207, 247, 30, false);
            CreateSeed( 2,351, 4, 207, 247, 39, false);
            CreateSeed( 2,351, 4, 207, 247, 42, false);
            CreateSeed( 2,348, 4, 141, 247, 42, false);
            CreateSeed( 2,348, 4, 141, 247, 18, false);
            CreateSeed( 2,348, 4, 141, 247, 27, false);
            CreateSeed( 2,348, 4, 141, 247, 39, false);
            CreateSeed( 2,348, 4, 144, 249, 39, false);
            CreateSeed( 2,346, 3, 138, 249, 33, false);
            CreateSeed( 2,346, 3, 138, 249, 21, false);
            CreateSeed( 2,346, 3, 138, 247, 24, false);
            CreateSeed( 2,346, 3, 141, 249, 27, false);
            CreateSeed( 2,346, 3, 138, 249, 36, false);
            CreateSeed( 2,346, 3, 138, 249, 24, false);
            CreateSeed( 2,346, 8, 138, 7, 36, false);
            CreateSeed( 2,346, 8, 138, 6, 36, false);
            CreateSeed( 2,346, 8, 162, 7, 36, false);
            CreateSeed( 2,342, 8, 147, 7, 36, false);
            CreateSeed( 2,342, 8, 147, 6, 36, false);
            CreateSeed( 2,342, 8, 147, 6, 33, false);
        } if(RAM[0x187] == 25 && RAM[0x18E] == 1) {
            CreateSeed( 1,437, 24, 255, 24, 174, false);
            CreateSeed( 1,398, 26, 255, 26, 141, false);
            CreateSeed( 1,395, 26, 255, 26, 171, false);
            CreateSeed( 1,364, 31, 255, 31, 174, false);
            CreateSeed( 1,341, 31, 255, 31, 213, false);
            CreateSeed( 1,333, 31, 255, 31, 243, false);
            CreateSeed( 1,327, 95, 255, 95, 234, false);
            CreateSeed( 1,304, 139, 255, 139, 111, false);
            CreateSeed( 1,265, 139, 255, 139, 177, false);
            CreateSeed( 1,255, 140, 255, 140, 138, false);
            CreateSeed( 1,254, 140, 255, 140, 171, false);
            CreateSeed( 1,245, 162, 255, 162, 75, false);
            CreateSeed( 1,243, 157, 255, 157, 147, false);
            CreateSeed( 1,233, 160, 255, 160, 141, false);
            CreateSeed( 1,202, 234, 255, 234, 174, false);
            CreateSeed( 1,111, 236, 255, 236, 207, false);
        } if(RAM[0x187] == 26 && RAM[0x18E] == 7) {
            CreateSeed( 1,164, 2, 255, 2, 141, false);
            CreateSeed( 1,162, 2, 255, 2, 174, false);
            CreateSeed( 2,428, 5, 255, 5, 120, false);
            CreateSeed( 1,162, 3, 255, 3, 174, false);
            CreateSeed( 1,162, 1, 255, 1, 174, false);
            CreateSeed( 2,418, 162, 255, 162, 252, false);
            CreateSeed( 2,383, 196, 255, 196, 240, false);
            CreateSeed( 2,368, 229, 255, 229, 24, false);
            CreateSeed( 2,368, 229, 255, 229, 36, false);
            CreateSeed( 2,346, 229, 255, 229, 252, false);
            CreateSeed( 2,301, 241, 255, 241, 18, false);
            CreateSeed( 1,162, 255, 255, 255, 174, false);
            CreateSeed( 1,162, 254, 255, 254, 174, false);
            CreateSeed( 1,162, 254, 255, 254, 174, false);
            CreateSeed( 3,432, 27, 246, 233, 21, false);
            CreateSeed( 3,432, 27, 249, 233, 21, false);
            CreateSeed( 3,430, 229, 234, 238, 48, false);
            CreateSeed( 3,428, 0, 234, 239, 57, false);
            CreateSeed( 3,428, 0, 237, 239, 57, false);
            CreateSeed( 2,301, 241, 255, 242, 30, false);
            CreateSeed( 2,299, 241, 255, 243, 33, false);
        } if(RAM[0x187] == 26 && RAM[0x18E] == 4) {
            CreateSeed( 1,132, 0, 255, 0, 243, false);
            CreateSeed( 2,415, 43, 255, 43, 210, false);
            CreateSeed( 2,403, 234, 255, 234, 240, false);
            CreateSeed( 2,403, 234, 255, 234, 240, false);
            CreateSeed( 2,403, 15, 243, 10, 54, false);
            CreateSeed( 2,403, 15, 246, 10, 54, false);
            CreateSeed( 2,403, 29, 255, 10, 60, false);
            CreateSeed( 2,403, 29, 255, 10, 63, false);
            CreateSeed( 2,400, 15, 237, 11, 54, false);
            CreateSeed( 2,394, 30, 210, 12, 18, false);
            CreateSeed( 2,394, 30, 213, 12, 18, false);
            CreateSeed( 2,394, 30, 210, 12, 21, false);
            CreateSeed( 2,394, 30, 213, 12, 21, false);
            CreateSeed( 2,394, 30, 210, 13, 18, false);
            CreateSeed( 2,394, 30, 252, 20, 30, false);
            CreateSeed( 2,394, 30, 252, 20, 33, false);
            CreateSeed( 2,394, 30, 252, 21, 24, false);
            CreateSeed( 2,394, 30, 255, 21, 24, false);
            CreateSeed( 2,394, 30, 255, 21, 30, false);
            CreateSeed( 2,394, 30, 252, 21, 33, false);
            CreateSeed( 2,394, 30, 255, 21, 33, false);
            CreateSeed( 2,394, 30, 252, 21, 36, false);
            CreateSeed( 2,394, 30, 255, 21, 36, false);
            CreateSeed( 2,394, 30, 255, 21, 42, false);
            CreateSeed( 2,394, 30, 252, 21, 45, false);
            CreateSeed( 2,386, 39, 243, 22, 18, false);
            CreateSeed( 2,386, 39, 246, 22, 18, false);
            CreateSeed( 2,386, 39, 243, 24, 18, false);
            CreateSeed( 2,386, 39, 243, 24, 21, false);
            CreateSeed( 2,371, 227, 252, 238, 18, false);
            CreateSeed( 2,371, 227, 255, 238, 18, false);
            CreateSeed( 2,371, 227, 252, 238, 21, false);
            CreateSeed( 2,371, 227, 255, 238, 21, false);
            CreateSeed( 2,367, 227, 237, 238, 30, false);
            CreateSeed( 2,367, 227, 240, 238, 30, false);
            CreateSeed( 2,367, 227, 243, 238, 30, false);
            CreateSeed( 2,367, 227, 237, 238, 33, false);
            CreateSeed( 2,367, 227, 240, 238, 33, false);
            CreateSeed( 2,367, 227, 243, 238, 33, false);
            CreateSeed( 2,366, 227, 234, 238, 42, false);
            CreateSeed( 2,366, 227, 237, 238, 42, false);
            CreateSeed( 2,366, 227, 234, 240, 30, false);
            CreateSeed( 2,366, 227, 237, 240, 30, false);
            CreateSeed( 2,366, 227, 234, 240, 33, false);
            CreateSeed( 2,366, 227, 237, 240, 33, false);
            CreateSeed( 2,366, 227, 234, 241, 18, false);
            CreateSeed( 2,366, 227, 237, 241, 18, false);
            CreateSeed(3, 460,229,234,8,24, false);
        } if(RAM[0x187] == 26 && RAM[0x18E] == 3) {
            CreateSeed( 1,333, 2, 255, 2, 249, false);
            CreateSeed( 1,242, 2, 255, 2, 246, false);
            CreateSeed( 1,242, 2, 255, 2, 243, false);
            CreateSeed( 1,207, 3, 255, 3, 234, false);
            CreateSeed( 1,144, 10, 255, 10, 201, false);
            CreateSeed( 2,375, 29, 255, 29, 51, false);
            CreateSeed( 2,375, 29, 255, 29, 48, false);
            CreateSeed( 2,375, 29, 255, 29, 36, false);
            CreateSeed( 2,375, 29, 255, 29, 21, false);
            CreateSeed( 1,114, 249, 255, 249, 219, false);
            CreateSeed( 2,375, 29, 255, 29, 21, false);
            CreateSeed( 2,365, 29, 255, 0, 30, false);
            CreateSeed( 2,365, 29, 255, 0, 42, false);
            CreateSeed( 2,365, 29, 255, 0, 45, false);
        } if(RAM[0x187] == 26 && RAM[0x18E] == 2) {
            CreateSeed( 1,240, 0, 255, 0, 174, false);
            CreateSeed( 2,429, 5, 255, 5, 243, false);
            CreateSeed( 1,237, 179, 255, 179, 234, false);
            CreateSeed( 1,237, 183, 255, 183, 204, false);
            CreateSeed( 1,237, 180, 255, 180, 204, false);
            CreateSeed( 1,237, 180, 255, 180, 207, false);
            CreateSeed( 1,237, 180, 255, 180, 237, false);
            CreateSeed( 2,416, 204, 255, 204, 21, false);
            CreateSeed( 2,416, 204, 255, 204, 18, false);
            CreateSeed( 2,415, 204, 255, 204, 36, false);
            CreateSeed( 1,209, 248, 255, 248, 210, false);
            CreateSeed( 1,184, 248, 255, 248, 207, false);
            CreateSeed( 2,415, 204, 255, 204, 36, false);
            CreateSeed( 2,405, 249, 210, 0, 18, false);
            CreateSeed( 2,392, 255, 243, 0, 21, false);
            CreateSeed( 2,366, 250, 252, 0, 21, false);
            CreateSeed( 2,364, 67, 243, 5, 33, false);
            CreateSeed( 2,354, 26, 210, 7, 18, false);
            CreateSeed( 2,342, 201, 252, 7, 18, false);
            CreateSeed( 2,342, 201, 255, 7, 18, false);
            CreateSeed( 2,342, 201, 255, 8, 18, false);
        } if(RAM[0x187] == 27 && RAM[0x18E] == 7) {
            CreateSeed( 1,127, 2, 255, 2, 147, false);
            CreateSeed( 1,115, 0, 255, 0, 144, false);
            CreateSeed( 2,325, 7, 255, 7, 174, false);
            CreateSeed( 3,371, 7, 255, 7, 255, false);
            CreateSeed( 2,323, 6, 255, 6, 207, false);
            CreateSeed( 2,323, 6, 255, 6, 210, false);
            CreateSeed( 2,251, 10, 255, 10, 213, false);
            CreateSeed( 2,249, 23, 255, 23, 237, false);
            CreateSeed( 2,244, 24, 255, 24, 219, false);
            CreateSeed( 3,315, 31, 255, 31, 246, false);
            CreateSeed( 4,376, 202, 255, 202, 237, false);
            CreateSeed( 2,244, 232, 255, 232, 129, false);
            CreateSeed( 2,244, 241, 255, 241, 252, false);
            CreateSeed( 2,244, 241, 255, 241, 252, false);
            CreateSeed( 1,115, 0, 255, 0, 144, false);
            CreateSeed( 3,315, 31, 255, 31, 246, false);
            CreateSeed( 3,303, 179, 204, 181, 36, false);
            CreateSeed( 3,303, 179, 204, 182, 36, false);
            CreateSeed( 3,303, 179, 207, 183, 33, false);
            CreateSeed( 3,303, 179, 204, 183, 39, false);
            CreateSeed( 3,303, 175, 243, 204, 24, false);
            CreateSeed( 3,303, 175, 243, 204, 30, false);
            CreateSeed( 3,303, 175, 246, 204, 30, false);
            CreateSeed( 3,303, 175, 243, 204, 33, false);
            CreateSeed( 3,303, 175, 243, 204, 42, false);
            CreateSeed( 3,303, 175, 243, 204, 45, false);
            CreateSeed( 3,303, 175, 246, 205, 21, false);
            CreateSeed( 3,300, 175, 240, 205, 30, false);
            CreateSeed( 3,300, 175, 240, 205, 39, false);
        } if(RAM[0x187] == 27 && RAM[0x18E] == 3) {
            CreateSeed( 1,293, 2, 255, 2, 138, false);
            CreateSeed( 1,276, 2, 255, 2, 141, false);
            CreateSeed( 2,407, 1, 255, 1, 60, false);
            CreateSeed( 2,407, 1, 255, 1, 57, false);
            CreateSeed( 2,407, 1, 255, 1, 54, false);
            CreateSeed( 2,407, 1, 255, 1, 51, false);
            CreateSeed( 2,357, 1, 255, 1, 48, false);
            CreateSeed( 2,357, 1, 255, 1, 45, false);
            CreateSeed( 2,351, 1, 255, 1, 42, false);
            CreateSeed( 2,351, 1, 255, 1, 39, false);
            CreateSeed( 2,351, 1, 255, 1, 27, false);
            CreateSeed( 2,351, 1, 255, 1, 21, false);
            CreateSeed( 2,351, 1, 255, 1, 18, false);
            CreateSeed( 1,273, 74, 255, 74, 174, false);
            CreateSeed( 1,182, 189, 255, 189, 195, false);
            CreateSeed( 1,180, 189, 255, 189, 192, false);
            CreateSeed( 2,345, 189, 255, 189, 33, false);
            CreateSeed( 2,345, 189, 255, 189, 30, false);
            CreateSeed( 2,345, 189, 255, 189, 27, false);
            CreateSeed( 2,345, 189, 255, 189, 18, false);
            CreateSeed( 1,150, 190, 255, 190, 201, false);
            CreateSeed( 2,345, 189, 255, 189, 18, false);
            CreateSeed( 2,318, 255, 234, 0, 18, false);
            CreateSeed( 2,317, 255, 246, 0, 21, false);
            CreateSeed( 2,317, 255, 243, 0, 24, false);
            CreateSeed( 2,317, 255, 243, 0, 27, false);
            CreateSeed( 2,317, 255, 243, 0, 36, false);
            CreateSeed( 2,317, 255, 243, 0, 39, false);
            CreateSeed( 2,314, 255, 240, 0, 42, false);
            CreateSeed( 2,314, 255, 240, 0, 45, false);
            CreateSeed( 2,311, 250, 243, 3, 21, false);
            CreateSeed( 2,311, 250, 240, 3, 24, false);
            CreateSeed( 2,308, 250, 234, 3, 30, false);
            CreateSeed( 2,308, 250, 234, 3, 33, false);
            CreateSeed( 2,308, 250, 234, 3, 42, false);
            CreateSeed( 2,308, 250, 234, 5, 33, false);
            CreateSeed( 2,308, 250, 237, 5, 45, false);
            CreateSeed( 3,449, 6, 213, 26, 51, false);
            CreateSeed( 3,449, 6, 216, 26, 51, false);
            CreateSeed( 3,428, 9, 237, 34, 36, false);
            CreateSeed( 3,428, 9, 240, 34, 36, false);
        } if(RAM[0x187] == 28 && RAM[0x18E] == 6) {
            CreateSeed( 1,372, 2, 255, 2, 42, false);
            CreateSeed( 2,388, 6, 255, 6, 66, false);
            CreateSeed( 2,388, 6, 255, 6, 54, false);
            CreateSeed( 1,341, 1, 255, 1, 234, false);
            CreateSeed( 1,299, 3, 255, 3, 174, false);
            CreateSeed( 1,282, 18, 255, 18, 144, false);
            CreateSeed( 1,282, 18, 255, 18, 147, false);
            CreateSeed( 2,366, 178, 255, 178, 252, false);
            CreateSeed( 3,423, 255, 255, 255, 123, false);
            CreateSeed( 2,357, 254, 255, 254, 246, false);
            CreateSeed( 2,343, 254, 255, 254, 255, false);
            CreateSeed( 3,419, 8, 243, 0, 21, false);
            CreateSeed( 3,419, 8, 246, 0, 21, false);
            CreateSeed( 2,343, 254, 255, 254, 255, false);
            CreateSeed( 1,282, 18, 255, 18, 147, false);
            CreateSeed( 3,383, 8, 237, 0, 27, false);
            CreateSeed( 2,320, 39, 234, 1, 21, false);
            CreateSeed( 2,320, 39, 237, 1, 21, false);
            CreateSeed( 2,320, 39, 234, 1, 24, false);
            CreateSeed( 2,320, 39, 237, 1, 24, false);
            CreateSeed( 2,320, 39, 234, 1, 39, false);
            CreateSeed( 2,320, 39, 237, 1, 39, false);
            CreateSeed( 3,375, 178, 249, 4, 30, false);
            CreateSeed( 3,374, 178, 252, 4, 36, false);
            CreateSeed( 3,358, 245, 204, 16, 21, false);
            CreateSeed( 3,358, 245, 207, 16, 21, false);
            CreateSeed( 4,439, 244, 210, 17, 51, false);
            CreateSeed( 3,353, 245, 204, 20, 21, false);
            CreateSeed( 3,353, 245, 207, 20, 21, false);
            CreateSeed( 2,319, 34, 237, 27, 30, false);
            CreateSeed( 2,319, 34, 240, 27, 30, false);
            CreateSeed( 2,319, 34, 240, 28, 30, false);
            CreateSeed( 2,319, 34, 237, 28, 42, false);
            CreateSeed( 2,319, 34, 240, 28, 42, false);
            CreateSeed( 2,314, 8, 237, 253, 42, false);
            CreateSeed( 2,314, 8, 240, 253, 42, false);
        } if(RAM[0x187] == 28 && RAM[0x18E] == 2) {
            CreateSeed( 1,411, 53, 255, 53, 18, false);
            CreateSeed( 1,329, 58, 255, 58, 174, false);
            CreateSeed( 1,313, 58, 255, 58, 237, false);
            CreateSeed( 1,284, 70, 255, 70, 108, false);
            CreateSeed( 1,273, 70, 255, 70, 141, false);
            CreateSeed( 1,268, 68, 255, 68, 141, false);
            CreateSeed( 1,268, 69, 255, 69, 138, false);
            CreateSeed( 2,404, 109, 255, 109, 237, false);
            CreateSeed( 1,252, 202, 255, 202, 123, false);
            CreateSeed( 1,252, 202, 255, 202, 120, false);
            CreateSeed( 1,222, 212, 255, 212, 135, false);
            CreateSeed( 1,219, 211, 255, 211, 144, false);
            CreateSeed( 1,219, 211, 255, 211, 141, false);
            CreateSeed( 1,219, 211, 255, 211, 138, false);
            CreateSeed( 1,218, 212, 255, 212, 144, false);
            CreateSeed( 2,367, 239, 255, 239, 243, false);
            CreateSeed( 2,327, 239, 255, 239, 225, false);
            CreateSeed( 1,218, 238, 255, 238, 240, false);
            CreateSeed( 1,207, 238, 255, 238, 177, false);
            CreateSeed( 1,207, 238, 255, 238, 177, false);
            CreateSeed( 2,318, 13, 246, 181, 45, false);
            CreateSeed( 2,317, 13, 249, 181, 48, false);
            CreateSeed( 2,312, 13, 249, 187, 48, false);
            CreateSeed( 2,312, 13, 252, 187, 48, false);
            CreateSeed( 2,309, 14, 243, 194, 33, false);
            CreateSeed( 2,308, 14, 237, 194, 45, false);
            CreateSeed( 2,308, 14, 240, 194, 45, false);
            CreateSeed( 2,305, 15, 213, 201, 45, false);
            CreateSeed( 2,304, 15, 213, 205, 33, false);
            CreateSeed( 2,301, 15, 204, 205, 48, false);
            CreateSeed( 2,301, 15, 207, 205, 48, false);
            CreateSeed( 2,301, 15, 207, 209, 45, false);
            CreateSeed( 2,301, 15, 207, 213, 27, false);
            CreateSeed( 2,300, 15, 204, 217, 33, false);
            CreateSeed( 2,300, 15, 207, 217, 33, false);
            CreateSeed( 2,299, 14, 207, 220, 33, false);
            CreateSeed( 2,299, 14, 207, 221, 33, false);
            CreateSeed( 2,299, 13, 210, 229, 24, false);
            CreateSeed( 2,299, 12, 210, 234, 24, false);
            CreateSeed( 2,299, 13, 210, 234, 24, false);
            CreateSeed( 2,298, 13, 141, 234, 24, false);
            CreateSeed( 2,297, 11, 141, 235, 24, false);
            CreateSeed( 2,297, 11, 141, 238, 24, false);
            CreateSeed( 2,297, 11, 141, 236, 24, false);
            CreateSeed( 2,297, 11, 141, 236, 21, false);
        } if(RAM[0x187] == 29 && RAM[0x18E] == 1) {
            CreateSeed( 1,198, 11, 255, 11, 180, false);
        } if(RAM[0x187] == 30 && RAM[0x18E] == 6) {
            CreateSeed( 1,447, 15, 255, 15, 36, false);
            CreateSeed( 1,394, 15, 255, 15, 174, false);
            CreateSeed( 1,339, 16, 255, 16, 42, false);
            CreateSeed( 2,403, 14, 255, 14, 30, false);
            CreateSeed( 2,400, 14, 255, 14, 222, false);
            CreateSeed( 1,332, 22, 255, 22, 141, false);
            CreateSeed( 1,203, 25, 255, 25, 111, false);
            CreateSeed( 2,323, 22, 255, 22, 210, false);
            CreateSeed( 2,322, 22, 255, 22, 216, false);
            CreateSeed( 2,306, 26, 255, 26, 141, false);
            CreateSeed( 1,178, 24, 255, 24, 87, false);
            CreateSeed( 2,224, 36, 255, 36, 132, false);
            CreateSeed( 3,446, 53, 255, 53, 210, false);
            CreateSeed( 3,446, 72, 255, 72, 249, false);
            CreateSeed( 3,412, 72, 255, 72, 216, false);
            CreateSeed( 3,412, 72, 255, 72, 216, false);
            CreateSeed( 1,178, 24, 255, 24, 87, false);
            CreateSeed( 3,411, 29, 255, 9, 48, false);
            CreateSeed( 3,411, 29, 252, 9, 60, false);
            CreateSeed( 3,411, 29, 255, 9, 60, false);
            CreateSeed( 3,315, 226, 252, 13, 21, false);
            CreateSeed( 3,315, 226, 255, 13, 21, false);
            CreateSeed( 3,311, 226, 237, 13, 33, false);
            CreateSeed( 3,311, 226, 240, 13, 33, false);
        } if(RAM[0x187] == 30 && RAM[0x18E] == 3) {
            CreateSeed( 1,435, 47, 255, 47, 234, false);
            CreateSeed( 1,408, 106, 255, 106, 177, false);
            CreateSeed( 1,311, 216, 255, 216, 213, false);
            CreateSeed( 1,287, 216, 255, 216, 210, false);
            CreateSeed( 1,287, 216, 255, 216, 207, false);
            CreateSeed( 2,369, 220, 255, 220, 237, false);
            CreateSeed( 1,287, 216, 255, 216, 207, false);
            CreateSeed( 3,419, 39, 252, 26, 18, false);
        }
        
        /**/
        /* This ensures that all pre-shots are covered. */
        /**/
        for(unsigned preang=0; preang<256; preang += 1)
        for(unsigned prevel=18; prevel<256; prevel += 3)
        {
            //if(RAM[0x187] == 13 && RAM[0x18E] == 3)
            //   if(preang > 19 && preang < 155) continue;
            CreateSeed(0,0, preang,255, preang, prevel, false);
            //LunarballLaunchManager2ns::MAX_FRAMES = 450;
        }
        /**/

        static SaveState itbegin;
        itbegin.Create();

        static unsigned generationno;
        static unsigned n_generations_no_improvement;
        n_generations_no_improvement = 0;
        static double best_scoring;
        static CandidateType best_candidate;
        best_scoring = -999999;
        
        /* Generate NUM_VARIATIONS for as many generations as needed */
        for(generationno=1; true; ++generationno)
        {
            static CandidateListType CandidateList;
            /* generate new scorings from models */
            if(generationno == 2)
            {
                if(DO_DUALSHOT)
                {
                    /* Each plausible two-shot combination... */
                    for(unsigned preang=0; preang<256; preang += 1)
                    for(unsigned prevel=18; prevel<=63; prevel += 3)
                    {
                        if(RAM[0x187] == 23 && RAM[0x18E] == 4)
                            if(preang < 156)continue;
                        if(RAM[0x187] == 26 && RAM[0x18E] == 4)
                            if(preang < 9)continue;
                        if(RAM[0x187] == 30 && RAM[0x18E] == 3)
                            if(preang < 193)continue;
                        
                        /*
                        if(preang==51) preang=52;
                        if(preang==164) preang=168;
                        */
                        //if(preang==200) preang=247;
                    
                        static const int dists[] = {
                            35,1,
                            40,3,
                            50,3,
                            70,4,
                            100,6,
                            128,14, -1};
                        int prevdist=0;
                        for(int n=0; dists[n*2] != -1; ++n)
                        {
                            int dist = dists[n*2];
                            int skip = dists[n*2+1];
                            for(; prevdist <= dist; prevdist += skip)
                            {
                                const unsigned minvel = 198; //171;
                                
                                for(unsigned vel=minvel; vel<256; vel+=3)
                                    CreateSeed(0, 0, ((preang-prevdist)&255), vel, (preang&0xFF), prevel, false);
                                if(prevdist != 0)
                                for(unsigned vel=minvel; vel<256; vel+=3)
                                    CreateSeed(0, 0, ((preang+prevdist)&255), vel, (preang&0xFF), prevel, false);
                            }
                            prevdist = dist;
                        }
                    }
                }
            }
            CandidateList = WinnerList;
            if(generationno > 2) CandidateList.clear();
            /*
            for(unsigned candno=0; candno<CandidateList.size(); ++candno)
                while(candno < CandidateList.size()
                && !covered_candidates[candno])
                {
                    CandidateList.erase(CandidateList.begin() + candno);
                }
            */

            if(DO_DUALSHOT && !WinnerList.empty() && generationno > 2)
            for(unsigned a=0; a<NUM_VARIATIONS; ++a)
            {
                // Take one of the best as a model, and mutate a copy of it
                unsigned randi = lrand48() % WinnerList.size();
                CandidateType tmp = WinnerList[randi];

                static const double minlog  = pow(LOGMUTAATIO, MINMUTAATIO);
                static const double maxlog  = pow(LOGMUTAATIO, MAXMUTAATIO);
                const double logpos = minlog + (a*(maxlog-minlog))/(NUM_VARIATIONS-1);
                const double mut_amount = log(logpos) / log(LOGMUTAATIO);
                
                //if(generationno == 1)
                //    fprintf(stderr, "Gen %u: mut_amount=%g\n", a, mut_amount);

                tmp.confidence = 0;
                tmp.Mutate(mut_amount);

                unsigned c = tmp.GetModel();
                if(covered_candidates[c]) continue;
                if(covered_preshots[c >> 16]) continue;
                covered_candidates[c] = true;

                CandidateList.push_back(tmp);
            }
            
            if(DO_DUALSHOT &&
              (CandidateList.empty() || n_generations_no_improvement > 0 /*|| generationno==1*/))
            for(unsigned a=0; a<NUM_RANDOMS; ++a)
            {
                CandidateType tmp; tmp.CreateRandom();

                unsigned c = tmp.GetModel();
                if(covered_candidates[c]) continue;
                if(covered_preshots[c >> 16]) continue;
                covered_candidates[c] = true;

                CandidateList.push_back(tmp);
            }

            ++n_generations_no_improvement;
                
            { 
            fprintf(stderr, "Generation %u: %u candidates based on %u; %u on 16-bit donelist, %lu on 32-bit\n",
                generationno, (unsigned)CandidateList.size(), (unsigned)WinnerList.size(),
                (unsigned) covered_preshots.count(),
                (unsigned long) covered_candidates.count() );
            }

            WinnerList.clear(); // list of old winners not needed at this point

            for(unsigned candno=0; candno<CandidateList.size(); ++candno)
                CandidateList[candno].key = candno;
            
            // Run the candidates
            while(RunCandidates(CandidateList, itbegin)) scrReturn(1);

            fprintf(stderr, "\r");
            
            for(unsigned candno=0; candno<CandidateList.size(); ++candno)
            {
                CandidateType* candit = &CandidateList[candno];
                candit->key = candno;

                if(candit->dummy_first)
                {
                    covered_preshots[candit->GetModel() >> 16] = true;
                }
            }

            // Sort the new-round candidates, best-first
            std::sort(CandidateList.begin(), CandidateList.end(),
                      std::mem_fun_ref(&CandidateType::BetterScoring));
            
            /* Check if there was a new improvement */
            for(unsigned candno=0; candno<CandidateList.size(); ++candno)
            {
                static CandidateType* candit;
                candit = &CandidateList[candno];

                if(candit->scoring > best_scoring)
                {
                    // reset the no-progress counter
                    best_scoring   = candit->scoring;
                    best_candidate = *candit;
                    n_generations_no_improvement = 0;
                }
                break; // No need to check further, as they're sorted by score
            }
            
            /* Always add the winners of each kind for seeding the next breed */
            for(unsigned n=1; n<10; ++n)
            {
                unsigned model, time = Winner::GetBestTimeWithPocketCount(n, model);
                if(time == 0) continue;
                CandidateType tmp;
                tmp.SetModel(model, false); // don't know if it's a dummy_first or not
                tmp.confidence = 1;
                tmp.scoring    = (n / (double)time);
                tmp.scoring += n * 1e-5;
                tmp.scoring += ((model/0x100)&0xFF) * (1e-5/256.0);
                tmp.scoring += ((model/0x1000000)&0xFF) * (1e-5/65536.0);
                tmp.scoring *= 131072;
                WinnerList.push_front(tmp);
            }
            
            for(unsigned n=0; n<WINNERS; ++n)
            {
                static const double minlog  = pow(LOGMUTAATIO, MINMUTAATIO);
                static const double maxlog  = pow(LOGMUTAATIO, MAXMUTAATIO);
                const double logpos = minlog + (n*(maxlog-minlog))/(WINNERS-1);
                const double mut_amount = log(logpos) / log(LOGMUTAATIO);
                
                unsigned sel_winner = (unsigned)(mut_amount * CandidateList.size());
                sel_winner %= CandidateList.size();
                
                WinnerList.push_back(CandidateList[sel_winner]);
            }
             
            Averaging quality_all, quality_best;
            for(CandidateListType::const_iterator i=WinnerList.begin();
                  i!=WinnerList.end(); ++i)
                quality_best.Cumulate(i->scoring);
            for(CandidateListType::const_iterator i=CandidateList.begin();
                  i!=CandidateList.end(); ++i)
                quality_all.Cumulate(i->scoring);
            
            fprintf(stderr, "Average quality of generation %u: %g (all), %g (inheritors)\n",
                generationno,
                quality_all.GetValue(), quality_best.GetValue());

            if(n_generations_no_improvement >= min_generations_no_improvement
            || !DO_DUALSHOT) break;
        } // proceed to next generation
        
      #undef CreateSeed

        Winner::Load();
        fprintf(stderr, "Beginning new shot\n");
        FCEUSS_Save("botfrontL-newshotbegin");
        goto BeginNewShot;

        scrFinish(0);
    }

    #undef RunFrameWith
};


void RunFrame() /* Called once every frame by the emulator */
{
    scrBegin;

    static LunarballLaunchManager2 code;
    while(1)
    {
        code.Run();
        scrReturnV;
    }
    FCEUSS_Save("botfrontL-end");

    scrFinishV;
}