diff --git a/RandomWriter/RandomWriter.pro b/RandomWriter/RandomWriter.pro
index 85bdbce..b25432f 100644
--- a/RandomWriter/RandomWriter.pro
+++ b/RandomWriter/RandomWriter.pro
@@ -110,7 +110,6 @@ win32 {
     QMAKE_LFLAGS += -Wl,--stack,536870912
     LIBS += -lDbghelp
     LIBS += -lbfd
-    LIBS += -liberty
     LIBS += -limagehlp
 }
 macx {
diff --git a/RandomWriter/src/RandomWriter.cpp b/RandomWriter/src/RandomWriter.cpp
index e591dac..67a30e7 100644
--- a/RandomWriter/src/RandomWriter.cpp
+++ b/RandomWriter/src/RandomWriter.cpp
@@ -6,9 +6,252 @@
 #include "random.h"
 #include "strlib.h"
 #include "vector.h"
+
 using namespace std;
 
+struct Statistic{
+    char letter;
+    int quantity;
+    double procent;
+};
+
+// global variables  section
+
+// main map of seeds and their letter statistics
+Map <string, Vector <Statistic>> seedsMap;
+
+// map of seed's frequency
+Map <string, int> seedFrequency;
+
+// model level
+int modelLevel=0;
+
+// length of output text
+const int numLettersToGenerate=2000;
+//
+
+/**
+ * @brief getValidFileFromUser ask user for a file name and validate it
+ * @return validated file name as string
+ */
+string getValidFileFromUser(){
+    string fName="";
+    while(true){
+        cout << "Enter file name: ";
+        cin >> fName;
+        ifstream ifs (fName);
+        if (ifs.is_open()){
+            break;
+        } else {
+            cout << "That file could not be opened. Try again. \n";
+        }
+    }
+    return fName;
+}
+
+/**
+ * @brief getValidModelLevelFromUser ask user for a valid model level
+ * @return model level in range 1-10
+ */
+int getValidModelLevelFromUser(){
+    int res=0;
+    while(true){
+        cout << "Enter model level (1-10): ";
+        cin >> res;
+        if ((res>0)&(res<=10)){
+            break;
+        } else {
+            cout << "That level is incorrect. Try again. \n";
+        }
+    }
+    return res;
+}
+
+/**
+ * @brief incrementCounterSeeds increment counter of frequecy for current seed
+ * @param seed, frequency of which must be increased.
+ */
+void incrementCounterSeeds(string lastSeed){
+    int counter=0;
+    if(seedFrequency.containsKey(lastSeed))
+        counter=seedFrequency.get(lastSeed);
+    counter++;
+    seedFrequency.put(lastSeed,counter);
+}
+
+/**
+ * @brief incrementCounterSeedsLetters increment counter of letter frequency for current seed.
+ * @param seed - working seed
+ * @param c - letter, frequency of which must be increased.
+ */
+void incrementCounterSeedsLetters(string seed, char c){
+    Vector <Statistic> statVector;
+
+    if(seedsMap.containsKey(seed))
+        statVector=seedsMap.get(seed);
+
+    bool isNewLetter=true;
+
+    for(int i=0;i<statVector.size();i++){
+        if(statVector[i].letter==c){
+            Statistic tmp=statVector[i];
+            tmp.quantity++;
+            statVector.set(i,tmp);
+            isNewLetter=false;
+        }
+    }
+
+    if(isNewLetter){
+        Statistic tmp;
+        tmp.letter=c;
+        tmp.quantity=1;
+        tmp.procent=0;
+        statVector.add(tmp);
+    }
+
+    seedsMap.put(seed,statVector);
+}
+
+/**
+ * @brief loadSeedMapsFromFile read and analise text file
+ * @param fName - name of file
+ */
+void loadSeedMapsFromFile(string fName){
+    ifstream ifs (fName);
+
+    string seed="";
+
+    while (!ifs.eof()) {
+        char c = ifs.get();
+        if (((int)(c)==-1)){
+            continue;
+        }
+        // debag
+        //cout << c;
+
+        string lastSeed = seed;
+
+        seed+=c;
+
+        if(seed.length() <= modelLevel)
+            continue;
+
+        incrementCounterSeeds(lastSeed);
+        incrementCounterSeedsLetters(lastSeed,c);
+
+        // cut first letter
+        seed=seed.substr(1,modelLevel);
+    }
+}
+
+/**
+ * @brief showSeedsMap proc needed only for debag - show full seeds map with letter's statistic
+ */
+void showSeedsMap(){
+    for(auto elem:seedsMap){
+        Vector <Statistic> tmp;
+        tmp=seedsMap.get(elem);
+        cout << elem << " -> ";
+        for(auto elv:tmp){
+            cout << " letter "<< elv.letter << "-" << elv.quantity<< "%" << elv.procent << " ";
+        }
+        cout << endl;
+    }
+}
+
+/**
+ * @brief countStatProcents - count percent of frequency for each letter of each seed.
+ */
+void countStatProcents(){
+    for(auto elem:seedsMap){
+        Vector <Statistic> statVector=seedsMap.get(elem);
+        int totalLettersInSeedVector=0;
+        for(auto letterStat:statVector){
+            totalLettersInSeedVector+=letterStat.quantity;
+        }
+        for(int i=0;i<statVector.size();i++){
+            Statistic tmp=statVector[i];
+            tmp.procent=(double)tmp.quantity/totalLettersInSeedVector;
+            statVector.set(i,tmp);
+        }
+        seedsMap.put(elem,statVector);
+    }
+}
+
+/**
+ * @brief getMostFrequentlyUsedSeed - seek most frequently used seed
+ * @return founded seed
+ */
+string getMostFrequentlyUsedSeed(){
+    int maxSN=0;
+    string maxSeed="";
+    for(auto el:seedFrequency){
+        int timesUsed=seedFrequency.get(el);
+        if(timesUsed>maxSN){
+            maxSN=timesUsed;
+            maxSeed=el;
+        }
+    }
+    return maxSeed;
+}
+
+/**
+ * @brief findLetterForSeed - randomly choose next letter for current seed, depending to letter's frequency statistic.
+ * @param seed - base seed
+ * @return founded char
+ */
+char findLetterForSeed(string seed){
+    char res='o';
+    Vector<Statistic> lettersStat=seedsMap.get(seed);
+    double rnddbl=randomReal(0, 1);
+    double currentSum=0;
+    for(auto letterStat:lettersStat){
+        currentSum+=letterStat.procent;
+        if(currentSum>rnddbl){
+            res=letterStat.letter;
+            break;
+        }
+    }
+    return res;
+}
+
+/**
+ * @brief generateRandomText - generate and show on screen randomized text
+ * @param startSeed - start seed, which begin from.
+ */
+void generateRandomText(string startSeed){
+    cout << startSeed;
+    string seed=startSeed;
+
+    for(int i=0;i<numLettersToGenerate;i++){
+        char c=findLetterForSeed(seed);
+        cout << c;
+        seed=seed.substr(1,modelLevel-1)+c;
+    }
+}
+
+/**
+ * main proc.
+ */
 int main() {
-    // TODO: fill in the code
-	return 0;
+
+    string fName=getValidFileFromUser();
+
+    modelLevel=getValidModelLevelFromUser();
+
+    loadSeedMapsFromFile(fName);
+
+    countStatProcents();
+
+    // debag
+    //showSeedsMap();
+
+    string startSeed=getMostFrequentlyUsedSeed();
+
+    // debag
+    //cout <<endl<<"Start seed: "<< startSeed;
+
+    generateRandomText(startSeed);
+
+    return 0;
 }
diff --git a/WordLadder/WordLadder.pro b/WordLadder/WordLadder.pro
index 85bdbce..b25432f 100644
--- a/WordLadder/WordLadder.pro
+++ b/WordLadder/WordLadder.pro
@@ -110,7 +110,6 @@ win32 {
     QMAKE_LFLAGS += -Wl,--stack,536870912
     LIBS += -lDbghelp
     LIBS += -lbfd
-    LIBS += -liberty
     LIBS += -limagehlp
 }
 macx {
diff --git a/WordLadder/src/WordLadder.cpp b/WordLadder/src/WordLadder.cpp
index 01d35d7..c44bd29 100644
--- a/WordLadder/src/WordLadder.cpp
+++ b/WordLadder/src/WordLadder.cpp
@@ -4,9 +4,204 @@
 #include "queue.h"
 #include "simpio.h"
 #include "vector.h"
+
 using namespace std;
 
-int main() {
-    // TODO: fill in the code
-	return 0;
+// read lexicon file
+Lexicon lex("EnglishWords.txt");
+
+// local word's dictionary
+Vector<string> dic;
+
+// declare source and final words
+string source_word;
+string final_word;
+
+/**
+ * @brief fillDic select words from lexicon depending to required word length
+ * @param wordLength - int length of words to select
+ */
+void fillDic(int wordLength){
+    dic.clear();
+    for(string word:lex){
+        if((word.length()==wordLength) && (word!=source_word))
+            dic.add(word);
+    }
+}
+
+/**
+ * @brief wordAlreadyInOldChain check if word already present in current chain
+ * @param wordToCheck - word to check
+ * @param Chain - vector of words to check in
+ * @return true - if present
+ */
+bool wordAlreadyInOldChain(string wordToCheck, Vector<string> & Chain){
+    bool res=false;
+    for(string usedWord:Chain){
+        if(usedWord==wordToCheck){
+            res=true;
+            break;
+        }
+    }
+    return res;
+}
+
+/**
+ * @brief numberDifferentLetters count number of different letters between words
+ * @param wordToCheck - word to check:)
+ * @param lastWord - word to compare with
+ * @return int number of differences
+ */
+int numberDifferentLetters(string wordToCheck,string lastWord){
+    int res=0;
+    for(int i=0; i<wordToCheck.size();i++)
+        if(!(wordToCheck[i]==lastWord[i]))
+            res++;
+    return res;
+}
+
+/**
+ * @brief findNewWordsInDic find new words in dictionary with one letter changed
+ * @param lastWord - current base word
+ * @param oldChain - current chain with used words
+ * @return vector of new words (string)
+ */
+Vector<string> findNewWordsInDic(string lastWord, Vector<string> & oldChain){
+    Vector<string> res;
+    // look for words, that not equ lastWord & has 1 difference in letters from it & is'nt in oldChain Vector.
+    int i=0;
+    for(string word:dic){
+        i++;
+        if((word==lastWord)||(word=="")||(wordAlreadyInOldChain(word,oldChain))||(numberDifferentLetters(word,lastWord)>1))
+            continue;
+        res.add(word);
+        dic[i-1]="";
+    }
+    return res;
+}
+
+/**
+ * @brief showChain show chain of words to screen
+ * @param currentChain - chain to show
+ */
+void showChain(Vector<string> & currentChain){
+    for(auto word:currentChain){
+        cout << word << " ";
+    }
+    cout << endl;
+}
+
+/**
+ * @brief takeWord ask user to enter word
+ * @param msg - prompt message
+ * @return string, entered by user.
+ */
+string takeWord(string msg){
+    string res;
+    cout << msg;
+    cin >> res;
+    return res;
+}
+
+/**
+ * @brief check if destination word not present in local dictionary.
+ * @return false - if present.
+ */
+bool finalWordNotInDictionary(){
+    bool res=true;
+    for(string word:dic){
+        if(word==final_word){
+            res=false;
+            break;
+        }
+    }
+    return res;
+}
+
+/**
+ * @brief removeChainWordsFromDic - remove deadlock words from local dictionary
+ * @param chain - vector of <string> words to be removed
+ */
+void removeChainWordsFromDic(Vector<string> & chain){
+    int i=0;
+    for(string dicElem:dic){
+        if(dicElem=="") // already removed
+            continue;
+        for(string chainElem:chain)
+            if(chainElem==dicElem){
+                dic.set(i,"");
+                break;
+            }
+        i++;
+    }
+}
+
+
+int main()
+{
+    while(true){
+        source_word=takeWord("Source word ('q' to exit): ");
+
+        if(source_word.length()==1)
+            break;
+
+        final_word=takeWord("Destination word: ");
+
+        cout << "I'm thinking..." << endl;
+
+        if(final_word.length()!=source_word.length()){
+            cout << "Detination word has incorrect length" << endl;
+            continue;
+        }
+
+        // fill local dictionary
+        fillDic(source_word.length());
+        cout << "Local dictionary: " << dic.size() << "words.\n";
+
+        // check for corrent length source and final words
+        if(finalWordNotInDictionary()){
+            cout << "Detination word is absent in dictionary" << endl;
+            continue;
+        }
+
+        // init first chain
+        Vector <string> chain;
+        chain.add(source_word);
+
+        // init chainsQueue
+        Queue<Vector<string>> chainsQueue;
+        chainsQueue.enqueue(chain);
+
+        bool chainFound=false;
+
+        // main search loop
+        while(chainsQueue.size()>0){
+            Vector <string> currentChain=chainsQueue.dequeue();
+            string lastWordOfCurrentChain=currentChain[currentChain.size()-1];
+
+            Vector <string> expandingWords=findNewWordsInDic(lastWordOfCurrentChain,currentChain);
+
+            if(expandingWords.size()==0){   // deadlock words chain found
+                removeChainWordsFromDic(currentChain);
+            } else {                        // expand the chainwith new words
+                for(auto word:expandingWords){
+                    Vector <string> newChain(currentChain);
+                    newChain.add(word);
+                    //check, if final_word found?!
+                    if(word==final_word){
+                        showChain(newChain);
+                        chainFound=true;
+                        break;
+                    }
+                    chainsQueue.enqueue(newChain);
+                }
+            }
+            if(chainFound)
+                break;
+        }
+        // message if not found chain...
+        if(chainsQueue.size()==0)
+            cout << "No chain between words:(" << endl;
+    }
+    return(0);
 }