#include <iostream>
#include <fstream>
#include <cassert>
#include <vector>
#include <string>
#include <sstream>
#include <set>

/* Update ROWS & COLUMNS for smaller/bigger input files */
#define ROWS 100000
#define COLUMNS 100

#define ABS(a) ((a)<0 ? (a)*(-1) : (a))
#define MAX(a,b) (((a)<(b)) ? (b) : (a))
#define MIN(a,b) (((a)>(b)) ? (b) : (a))

#define SET(x,byte) memset(x,byte,sizeof(x));
#define REP(i,mx) for(int i=0;(i)<(mx);i++)
#define RFOR(i,mx,mn) for(int i=(mx);(i)>=(mn);i--)
#define FOR(i,mn,mx) for(int i=mn;(i)<=(mx);i++)
#define SSTR(X) dynamic_cast<std::ostringstream&>((std::ostringstream()<<std::dec<<X)).str()

#define DICT_SIZE 300000
#define WORD_COLUMN 0
#define NUMBER_COLUMN 1

using namespace std;

vector<string> wordDict;
set<string> wordDictUnique;
vector<int> numberDict;
vector<string> outputLines(ROWS, "");

// poor man's random choose, gives 99% accurate random distribution
bool randChoose(int percToChoose) {
    assert(percToChoose >= 0);
    assert(percToChoose <= 100);
    
    if(rand()%100 + 1 <= percToChoose) 
        return true;
    return false;
}

// column type, 50-50 probability
inline int randomColumnType() {if(randChoose(50)) return WORD_COLUMN; return NUMBER_COLUMN;}

//random word from dictionary
inline string randomWord() { return wordDict[(int)rand()%(wordDict.size())];} 

vector<string> randomWordColumn() { 
    assert(wordDict.size() == DICT_SIZE); 
    int start = rand()%(DICT_SIZE - ROWS); 
    return vector<string>(wordDict.begin() + start, wordDict.begin() + start + ROWS);
}
vector<int> randomNumberColumn() { 
    assert(numberDict.size() == DICT_SIZE); 
    int start = rand()%(DICT_SIZE - ROWS); 
    return vector<int>(numberDict.begin() + start, numberDict.begin() + start + ROWS);
}

int main() {
    assert (ROWS <= 100000);
    assert (COLUMNS <= 100);

    srand(time(NULL));
    ifstream dictin;
    dictin.open("dict.txt");
    string tmp;
    while(dictin>>tmp) wordDictUnique.insert(tmp);
    dictin.close();

    wordDict = vector<string>(wordDictUnique.begin(), wordDictUnique.end());
    //fill dictionary with new words, by concatenating 2 words
    while(wordDictUnique.size() < DICT_SIZE)
        wordDictUnique.insert(randomWord() + randomWord());
    
    wordDict.clear();
    wordDict = vector<string>(wordDictUnique.begin(), wordDictUnique.end());
    
    //random shuffle dictionary
    random_shuffle(wordDict.begin(), wordDict.end());
    
    //generate random numberDict
    REP(i, DICT_SIZE)
        numberDict.push_back(i);
    random_shuffle(numberDict.begin(), numberDict.end());

    FOR(i, 1, COLUMNS) {
        int columnType = randomColumnType();
        if (columnType == WORD_COLUMN) {
            vector<string> newColumn = randomWordColumn();
            assert(newColumn.size() == ROWS);
            
            REP(j, ROWS) {
                if(i != 1) outputLines[j] += " ";
                outputLines[j] += newColumn[j];
            }
        } else if (columnType == NUMBER_COLUMN) {
            vector<int> newColumn = randomNumberColumn();

            assert(newColumn.size() == ROWS);

            REP(j, ROWS) {
                if(i != 1) outputLines[j] += " ";
                outputLines[j] += SSTR(newColumn[j]);
            }
        }
    }

    ofstream out;
    out.open("sample_input.txt");
    REP(i, ROWS) out<<outputLines[i]<<endl;
    out.close();

    return 0;
}