Quick hacked up C++ version

#include <stdlib.h>
#include <stdio.h>
#include <string.h>

#include <vector>
#include <inttypes.h>

using std::vector;

const uint32_t TILE_DIM = 50;
const uint32_t MIW = 2;
const uint32_t MAXWID = 8;

double b_noise = 19.191919191919191919191919191919191919191919191919191919191919191919191919191919;

uint32_t nextRandomScaledInt( uint32_t scaleFactor)
{
    b_noise = b_noise * b_noise;
    int i_noise = (int)b_noise;
    b_noise = b_noise - i_noise;

    double noise_out = b_noise * (scaleFactor-1);

    b_noise = b_noise + 19;

    return (uint32_t)noise_out;
}

struct Tile
{
    int X;
    int Y;
    int T;
};

struct Room
{
    int startX;
    int endX;
    int startY;
    int endY;
//    int W;
//    int H;
    int N;
};

struct Lev
{
//    struct Tile ts[2500];
//    struct Room rs[100];
//    int lenrs;
    vector<Tile> ts;
    vector<Room> rs;
    uint32_t lenrs;
    Lev() :
        ts( 2500 ),
        rs( 100 ),
        lenrs( 0 )
    {
    };
};

int CheckColl( int startX, int endX, int startY, int endY, vector<Room> & rs, int lenrs )
//int CheckColl( int startX, int endX, int startY, int endY, int w, int h, vector<Room> & rs, int lenrs )
{
    int testStartX( startX - 1 );
    int testEndX( endX + 1 );
    int testStartY( startY - 1 );
    int testEndY( endY + 1 );
    int i = 0;
    for( i = 0; i < lenrs; i++ )
    {
        int & rstartX = rs[i].startX;
        int & rendX = rs[i].endX;
        int & rstartY = rs[i].startY;
        int & rendY = rs[i].endY;
//        int rw = rs[i].W;
//        int rh = rs[i].H;
        int RoomOkay;

        if( rendX < testStartX || rstartX > testEndX )
//            if( ( rendX + 1 ) < startX || rstartX > ( endX + 1 ) )
//        if( ( rstartX + rw + 1 ) < startX || rstartX > ( startX + w + 1 ) )
        {
            RoomOkay = 1;
        }
        else if( rendY < testStartY || rstartY > testEndY )
//            else if( ( rendY + 1 ) < startY || rstartY > ( endY + 1 ) )
//        else if( ( rstartY + rh + 1 ) < startY || rstartY > ( startY + h + 1 ) )
        {
            RoomOkay = 1;
        }
        else
        {
            RoomOkay = 0;
        }
        if( RoomOkay == 0 )
            return 1;
    }
    return 0;
}

void MakeRoom( vector<Room> & rs, int & lenrs )
{
    //int startX = rand() % TILE_DIM;
    //int startY = rand() % TILE_DIM;
    //int w = rand() % MAXWID + MIW;
    //int h = rand() % MAXWID + MIW;
    int startX = nextRandomScaledInt(TILE_DIM);
    int startY = nextRandomScaledInt( TILE_DIM );
    int w = nextRandomScaledInt( MAXWID ) + MIW;
    int h = nextRandomScaledInt( MAXWID ) + MIW;
    int endX = startX + w;
    int endY = startY + h;

    if( endX >= TILE_DIM || endY >= TILE_DIM || startX == 0 || startY == 0 )
        return;
    int nocrash = CheckColl( startX, endX, startY, endY, rs, lenrs );
//    int nocrash = CheckColl( startX, endX, startY, endY, w, h, rs, lenrs );
    if( nocrash == 0 )
    {
        rs[lenrs].startX = startX;
        rs[lenrs].endX = endX;
        rs[lenrs].startY = startY;
        rs[lenrs].endY = endY;
//        rs[lenrs].W = w;
//        rs[lenrs].H = h;
        rs[lenrs].N = lenrs;
        lenrs = lenrs + 1;
    }
}

void Room2Tiles( Room & r, vector<Tile> & ts )
{
    const int & startX = r.startX;
    const int & endX = r.endX;
    const int & startY = r.startY;
    const int & endY = r.endY;
//    const int & w = r.W;
//    const int & h = r.H;
    int xi;
    int yi;
    for( xi = startX; xi <= endX; xi++ )
    {
        for( yi = startY; yi <= endY; yi++ )
        {
            int num = yi * TILE_DIM + xi;
            ts[num].T = 1;
        }
    }
}

void PrintLev( Lev & l )
{
    int i = 0;
    for( i = 0; i < 2500; i++ )
    {
        printf( "%d", l.ts[i].T );
        if( i % ( TILE_DIM ) == 49 && i != 0 )
            printf( "\n" );
    }
}

int main( int argc, char* argv[] )
{
    int v = atoi( argv[1] );
    printf( "The random seed is: %d \n", v );
    srand( v );

    char doubleNoiseStarter[4096];
    sprintf( doubleNoiseStarter, "19.8%s", argv[1] );
    b_noise = atof( doubleNoiseStarter );
    printf("Set noise seed to %lf\n", b_noise );

    int i;
    int ii;
    vector<Lev> ls(100);
    int lenLS = 0;
    vector<Room> rs( 100 );

    vector<Tile> ts( 2500 );
    for( ii = 0; ii < 2500; ii++ )
    {
        ts[ii].X = ii % TILE_DIM;
        ts[ii].Y = ii / TILE_DIM;
    }

    for( i = 0; i < 100; i++ )
    {
        int lenrs = 0;
        for( ii = 0; ii < 50000; ii++ )
        {
            MakeRoom( rs, lenrs );
            if( lenrs == 99 )
            {
                break;
            }
        }
        for( ii = 0; ii < 2500; ii++ )
        {
            ts[ii].T = 0;
        }
        for( ii = 0; ii < lenrs; ii++ )
        {
            Room2Tiles( rs[ii], ts );
        }

        ls[lenLS].rs = rs;
        ls[lenLS].ts = ts;
        ls[lenLS].lenrs = lenrs;
        lenLS++;
    }

    Lev & templ( ls[0] );

    for( i = 1; i < 100; i++ )
    {
        if( ls[i].lenrs > templ.lenrs )
        {
            templ = ls[i];
        }
    }
    PrintLev( templ );

}