diff --git a/CHANGELOG.md b/CHANGELOG.md
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -98,3 +98,11 @@
 
 * Eigth version revised A. Fixed issue with the wrong order and, therefore, mapping for different choices and
 the corresponding properties in the module Phonetic.Languages.Simplified.Array.Ukrainian.FuncRep2RelatedG2.
+
+## 0.9.0.0 -- 2021-08-16
+
+* Ninth version. Added new properties that try to increase the importance of the ending of the line and decrease
+the importance of the beginning of the line. Added new dependency of string-interpreter. Added the possibility
+to run lineVariantsG3 and the corresponding library functions in the recursive interactive mode. It is not
+compatible with the contstraints so should be used not simultaneously with them (because they change their meaning).
+Some documentation improvements.
diff --git a/Phonetic/Languages/Simple.hs b/Phonetic/Languages/Simple.hs
--- a/Phonetic/Languages/Simple.hs
+++ b/Phonetic/Languages/Simple.hs
@@ -22,7 +22,7 @@
 import Phonetic.Languages.Array.Ukrainian.PropertiesSyllablesG2
 import Phonetic.Languages.Filters (unsafeSwapVecIWithMaxI)
 import Phonetic.Languages.Simplified.StrictVG.Base
-import Data.Char (isDigit,isAlpha)
+import Data.Char (isDigit,isAlpha,isLetter)
 import qualified Data.List  as L (span,sort,zip4,isPrefixOf,nub)
 import Phonetic.Languages.Simplified.Array.Ukrainian.FuncRep2RelatedG2
 import Phonetic.Languages.Permutations.Arr
@@ -33,6 +33,7 @@
 import Phonetic.Languages.Simplified.DeEnCoding
 import Phonetic.Languages.Simplified.SimpleConstraints
 import Phonetic.Languages.Common
+import Interpreter.StringConversion (convStringInterpreter)
 
 forMultiplePropertiesF :: [String] -> [(String,[String])]
 forMultiplePropertiesF (xs:xss)
@@ -53,27 +54,51 @@
 (the default values here are 1.0 both).
 @ since 0.6.0.0
 Changed the arguments signing so that capital letters changed to the small ones, double ++ changed to just singular +.
+@ since 0.9.0.0
+Added a new argument to control whether to use interactive recursive mode.
 
 -}
-generalProc2G :: Bool -> FilePath -> Bool -> Bool -> [String] -> Coeffs2 -> Coeffs2 -> [String] -> Bool -> IO ()
-generalProc2G nativeUkrainian toFile1 interactive jstL0 args0 coeffs coeffsWX args lstW2
+generalProc2G
+ :: Bool
+ -> Bool
+ -> FilePath
+ -> Bool
+ -> Bool
+ -> [String]
+ -> Coeffs2
+ -> Coeffs2
+ -> [String]
+ -> Bool
+ -> IO ()
+generalProc2G recursiveMode nativeUkrainian toFile1 interactive jstL0 args0 coeffs coeffsWX args lstW2
  | variations args = do
     let !zsss = transformToVariations args
     print zsss
-    variantsG <- mapM (\xss -> generalProc2 nativeUkrainian interactive jstL0 args0 coeffs coeffsWX xss lstW2) zsss
-    interactivePrintResult nativeUkrainian id variantsG >>= \rs ->
+    variantsG <- mapM (\xss -> generalProc2 recursiveMode nativeUkrainian interactive jstL0 args0 coeffs coeffsWX xss lstW2) zsss
+    (if recursiveMode then interactivePrintResultRecursive recursiveMode nativeUkrainian interactive jstL0 args0 coeffs coeffsWX id variantsG args lstW2
+     else interactivePrintResult nativeUkrainian id variantsG) >>= \rs ->
       case toFile1 of
        "" -> return ()
        ~fileName -> appendFile fileName (rs `mappend` newLineEnding)
- | otherwise = generalProc2 nativeUkrainian interactive jstL0 args0 coeffs coeffsWX args lstW2 >>= \rs ->
+ | otherwise = generalProc2 recursiveMode nativeUkrainian interactive jstL0 args0 coeffs coeffsWX args lstW2 >>= \rs ->
       case toFile1 of
        "" -> return ()
        ~fileName -> appendFile fileName (rs `mappend` newLineEnding)
 
 -- |
 -- @ since 0.3.0.0 The result is not 'IO' (), but 'IO' 'String'. The type also changed generally.
-generalProc2 :: Bool -> Bool -> Bool -> [String] -> Coeffs2 -> Coeffs2 -> [String] -> Bool -> IO String
-generalProc2 nativeUkrainian interactive jstL0 args0 coeffs coeffsWX args lstW2 = do
+generalProc2
+ :: Bool
+ -> Bool
+ -> Bool
+ -> Bool
+ -> [String]
+ -> Coeffs2
+ -> Coeffs2
+ -> [String]
+ -> Bool
+ -> IO String
+generalProc2 recursiveMode nativeUkrainian interactive jstL0 args0 coeffs coeffsWX args lstW2 = do
   let !argMss = take 5 . filter (not . null) . forMultiplePropertiesF . drop 1 . dropWhile (/= "+m") . takeWhile (/= "-m") $ args0
   if null argMss then do
    let (!numericArgs,!textualArgs) = L.span (all isDigit) $ args
@@ -86,18 +111,21 @@
        !intervalNmbrs = (\zs -> if null zs then [numberI] else L.nub zs) . L.sort . filter (<= numberI) .
            map (\t -> fromMaybe numberI $ (readMaybe t::Maybe Int)) . drop 2 $ numericArgs
    if compare l 2 == LT then let !frep20 = if take 1 choice == "x" || take 1 choice == "w" then chooseMax id coeffsWX choice else chooseMax id coeffs choice in let !wwss = (:[]) . toResultR frep20 $ xs in
-    if interactive then interactivePrintResult nativeUkrainian line wwss else print1el jstL0 choice wwss
+    if recursiveMode then interactivePrintResultRecursive recursiveMode nativeUkrainian interactive jstL0 args0 coeffs coeffsWX line wwss args lstW2
+    else if interactive then interactivePrintResult nativeUkrainian line wwss else print1el jstL0 choice wwss
    else do
     let !subs = subG " 01-" xs
     if null argCs then let !perms = genPermutationsL l in do
           temp <- generalProcMs coeffs coeffsWX perms subs (intervalNmbrs, arg0, numberI, choice)
-          if interactive then interactivePrintResult nativeUkrainian line temp else print1el jstL0 choice temp
+          if recursiveMode then interactivePrintResultRecursive recursiveMode nativeUkrainian interactive jstL0 args0 coeffs coeffsWX line temp args lstW2
+          else if interactive then interactivePrintResult nativeUkrainian line temp else print1el jstL0 choice temp
     else do
      correct <- printWarning nativeUkrainian xs
      if correct == "n" then putStrLn (messageInfo 1 nativeUkrainian) >> return "" -- for the multiple variations mode (with curly brackets and slash in the text) the program does not stop here, but the variation is made empty and is proposed further as a variant.
      else let !perms = decodeLConstraints argCs . genPermutationsL $ l in do
           temp <- generalProcMs coeffs coeffsWX perms subs (intervalNmbrs, arg0, numberI, choice)
-          if interactive then interactivePrintResult nativeUkrainian line temp else print1el jstL0 choice temp
+          if recursiveMode then interactivePrintResultRecursive recursiveMode nativeUkrainian interactive jstL0 args0 coeffs coeffsWX line temp args lstW2
+          else if interactive then interactivePrintResult nativeUkrainian line temp else print1el jstL0 choice temp
   else do
    let !choices = map fst argMss
        !numericArgss = map snd argMss
@@ -111,14 +139,17 @@
        !l = length . words $ xs
        !argCs = catMaybes (fmap (readMaybeECG (l - 1)) . (showB l lstW2:) . drop 1 . dropWhile (/= "+a") . takeWhile (/= "-a") $ args0)
    if compare l 2 == LT then let !frep20 = chooseMax id coeffs (concat . take 1 $ choices)
-    in let !wwss = (:[]) . toResultR frep20 $ xs in if interactive then interactivePrintResult nativeUkrainian line wwss else print1el jstL0 (concat . take 1 $ choices) wwss
+    in let !wwss = (:[]) . toResultR frep20 $ xs in
+         if recursiveMode then interactivePrintResultRecursive recursiveMode nativeUkrainian interactive jstL0 args0 coeffs coeffsWX line wwss args lstW2
+         else if interactive then interactivePrintResult nativeUkrainian line wwss else print1el jstL0 (concat . take 1 $ choices) wwss
    else do
     let !subs = subG " 01-" xs
-    if null argCs then let !perms = genPermutationsL l in generalProcMMs nativeUkrainian interactive coeffs coeffsWX argsZipped perms subs
+    if null argCs then let !perms = genPermutationsL l in
+       generalProcMMs recursiveMode nativeUkrainian interactive jstL0 args0 coeffs coeffsWX argsZipped perms subs args lstW2
     else do
      correct <- printWarning nativeUkrainian xs
      if correct == "n" then putStrLn (messageInfo 1 nativeUkrainian) >> return "" -- for the multiple variations mode (with curly brackets and slash in the text) the program does not stop here, but the variation is made empty and is proposed further as a variant.
-     else let !perms = decodeLConstraints argCs . genPermutationsL $ l in generalProcMMs nativeUkrainian interactive coeffs coeffsWX argsZipped perms subs
+     else let !perms = decodeLConstraints argCs . genPermutationsL $ l in generalProcMMs recursiveMode nativeUkrainian interactive jstL0 args0 coeffs coeffsWX argsZipped perms subs args lstW2
 
 {-|
 -- @ since 0.4.0.0
@@ -131,6 +162,7 @@
  | n == 3 = "Будь ласка, перевірте, чи рядок нижче відповідає і узгоджується з обмеженнями, які Ви вказали між +a та -a опціями. Перевірте також, чи Ви вказали \"+b\" чи \"+bl\" опцію(ї). Якщо введені опції та аргументи не узгоджені з виведеним далі рядком, тоді введіть далі \"n\", натисніть Enter і опісля запустіть програму на виконання знову з кращими аргументами. " `mappend` newLineEnding `mappend` "Якщо рядок узгоджується з Вашим вводом між +a та -a, тоді просто натисніть Enter, щоб продовжити далі. " `mappend` newLineEnding
  | n == 4 = "Було задано недостатньо інформації для продовження обчислювального процесу "
  | n == 5 = "(/ Ви вказали властивості(ість) та діапазон(и) для них такі, що для даних слів та їх сполучень варіантів немає. Спробуйте змінити параметри виклику програми (бібліотеки) /)"
+ | n == 6 = "Якщо бажаєте запустити програму (функцію) рекурсивно, змінюючи сполучення слів та букв, введіть тут закодований рядок інтерпретатора. Якщо бажаєте не використовувати програму (функцію) рекурсивно, просто натисніть Enter. "
  | otherwise = "Ви вказали лише один варіант властивостей. "
 messageInfo n False
  | n == 1 = "You stopped the program, please, if needed, run it again with better arguments. "
@@ -138,25 +170,60 @@
  | n == 3 = "Please, check whether the line below corresponds and is consistent with the constraints you have specified between the +a and -a options. Check also whether you have specified the \"+b\" or \"+bl\" option(s). If it is inconsistent then enter further \"n\", press Enter and then run the program again with better arguments. " `mappend` newLineEnding `mappend` "If the line is consistent with your input between +a and -a then just press Enter to proceed further. " `mappend` newLineEnding
  | n == 4 = "No data has been specified to control the computation process. "
  | n == 5 = "(/ You have specified properties / property and the range(s) so that for the words and their concatenations there are no variants available. Try to change the call parameters /)"
+ | n == 6 = "If you would like to run the program (call the function) recursively with changes for the words or letter connections then, please, enter here the encoded string of the interpreter. If you would NOT like to use it recursively, then just press Enter."
  | otherwise = "You have specified just one variant of the properties. "
 
 -- |
 -- @ since 0.3.0.0 The result is not 'IO' (), but 'IO' 'String'. The type also changed generally.
 -- @ since 0.8.0.0 The function has also the option for the empty result.
-interactivePrintResult :: Bool -> (a -> String) -> [a] -> IO String
+interactivePrintResult
+ :: Bool
+ -> (a -> String)
+ -> [a]
+ -> IO String
 interactivePrintResult nativeUkrainian f xss
-  | null xss = putStrLn "" >> return ""
+  | null xss = (putStrLn . messageInfo 5 $ nativeUkrainian) >> return ""
   | otherwise = do
      let !datas = map (\(idx,str) -> show idx `mappend` ('\t' : str)) . trans232 . map f $ xss
-     if null datas then (putStrLn . messageInfo 5 $ nativeUkrainian) >> return ""
+     mapM_ putStrLn datas
+     putStrLn ""
+     putStrLn . messageInfo 2 $ nativeUkrainian
+     number <- getLine
+     let !lineRes = concat . filter ((number `mappend` "\t")`L.isPrefixOf`) $ datas
+         !ts = drop 1 . dropWhile (/= '\t') $ lineRes
+     putStrLn ts >> return ts
+
+interactivePrintResultRecursive
+ :: Bool
+ -> Bool
+ -> Bool
+ -> Bool
+ -> [String]
+ -> Coeffs2
+ -> Coeffs2
+ -> (a -> String)
+ -> [a]
+ -> [String]
+ -> Bool
+ -> IO String
+interactivePrintResultRecursive recursiveMode nativeUkrainian interactive jstL0 args0 coeffs coeffsWX f xss args lstW2
+  | null xss = (putStrLn . messageInfo 5 $ nativeUkrainian) >> return ""
+  | otherwise = do
+     let !datas = map (\(idx,str) -> show idx `mappend` ('\t' : str)) . trans232 . map f $ xss
+     mapM_ putStrLn datas
+     putStrLn ""
+     putStrLn . messageInfo 2 $ nativeUkrainian
+     number <- getLine
+     let !lineRes = concat . filter ((number `mappend` "\t")`L.isPrefixOf`) $ datas
+         !ts = drop 1 . dropWhile (/= '\t') $ lineRes
+     putStrLn . messageInfo 6 $ nativeUkrainian
+     stringInterpreted <- getLine
+     if null stringInterpreted then putStrLn ts >> return ts
      else do
-      mapM_ putStrLn datas
-      putStrLn ""
-      putStrLn . messageInfo 2 $ nativeUkrainian
-      number <- getLine
-      let !lineRes = concat . filter ((number `mappend` "\t")`L.isPrefixOf`) $ datas
-          !ts = drop 1 . dropWhile (/= '\t') $ lineRes
-      putStrLn ts >> return ts
+       let strIntrpr = convStringInterpreter stringInterpreted ts
+           wordsNN = take 7 . words $ strIntrpr
+           !firstArgs = takeWhile (not . all isLetter) args
+       generalProc2 recursiveMode nativeUkrainian interactive jstL0 args0 coeffs coeffsWX (firstArgs `mappend` wordsNN) lstW2
 
 printWarning :: Bool -> String -> IO String
 printWarning nativeUkrainian xs = do
@@ -164,7 +231,13 @@
   putStrLn xs
   getLine
 
-generalProcMs :: Coeffs2 -> Coeffs2 -> [Array Int Int] -> [String] -> ([Int],Int,Int,String) -> IO [Result [] Char Double Double]
+generalProcMs
+ :: Coeffs2
+ -> Coeffs2
+ -> [Array Int Int]
+ -> [String]
+ -> ([Int],Int,Int,String)
+ -> IO [Result [] Char Double Double]
 generalProcMs coeffs coeffsWX perms subs (intervalNmbrs, arg0, numberI, choice) = do
   if compare numberI 2 == LT then let !frep2 = if take 1 choice == "x" || take 1 choice == "w" then chooseMax id coeffsWX choice else chooseMax id coeffs choice
    in return . fst . maximumGroupsClassificationR arg0 . map (toResultR frep2) . uniquenessVariants2GNBL ' ' id id id perms $ subs
@@ -177,16 +250,29 @@
 
 -- |
 -- @ since 0.3.0.0 The result is not 'IO' (), but 'IO' 'String'. The type also changed generally.
-generalProcMMs :: Bool -> Bool -> Coeffs2 -> Coeffs2 -> [([Int],Int,Int,String)] -> [Array Int Int] -> [String] -> IO String
-generalProcMMs nativeUkrainian interactiveMM coeffs coeffsWX rs perms subs =
+generalProcMMs
+ :: Bool
+ -> Bool
+ -> Bool
+ -> Bool
+ -> [String]
+ -> Coeffs2
+ -> Coeffs2
+ -> [([Int],Int,Int,String)]
+ -> [Array Int Int]
+ -> [String]
+ -> [String]
+ -> Bool
+ -> IO String
+generalProcMMs recursiveMode nativeUkrainian interactiveMM jstL0 args0 coeffs coeffsWX rs perms subs args lstW2 =
  case length rs of
   0 -> putStrLn (messageInfo 4 nativeUkrainian) >> return ""
   1 -> putStrLn (messageInfo 5 nativeUkrainian) >> do
         temp <- generalProcMs coeffs coeffsWX perms subs (head rs)
-        finalProc nativeUkrainian interactiveMM line temp
+        finalProc recursiveMode nativeUkrainian interactiveMM jstL0 args0 coeffs coeffsWX line temp args lstW2
   _ -> do
          genVariants <- mapM (generalProcMs coeffs coeffsWX perms subs) rs
-         finalProc nativeUkrainian interactiveMM id . foldlI . map (map line) $ genVariants
+         finalProc recursiveMode nativeUkrainian interactiveMM jstL0 args0 coeffs coeffsWX id (foldlI . map (map line) $ genVariants) args lstW2
 
 foldlI :: [[String]] -> [String]
 foldlI (xs:ys:xss) = foldlI (intersectInterResults xs ys : xss)
@@ -195,13 +281,31 @@
 
 -- |
 -- @ since 0.3.0.0 The result is not 'IO' (), but 'IO' 'String'. The type also changed generally.
-finalProc :: Bool -> Bool -> (a -> String) -> [a] -> IO String
-finalProc nativeUkrainian bool f xss = if bool then interactivePrintResult nativeUkrainian f xss else putStrLn ts >> return ts
+finalProc
+ :: Bool
+ -> Bool
+ -> Bool
+ -> Bool
+ -> [String]
+ -> Coeffs2
+ -> Coeffs2
+ -> (a -> String)
+ -> [a]
+ -> [String]
+ -> Bool
+ -> IO String
+finalProc recursiveMode nativeUkrainian interactive jstL0 args0 coeffs coeffsWX f xss args lstW2
+ | recursiveMode = interactivePrintResultRecursive recursiveMode nativeUkrainian interactive jstL0 args0 coeffs coeffsWX f xss args lstW2
+ | otherwise = if interactive then interactivePrintResult nativeUkrainian f xss else putStrLn ts >> return ts
   where ts = concatMap (\t -> f t `mappend` newLineEnding) xss
 
 -- |
 -- @ since 0.3.0.0 The result is not 'IO' (), but 'IO' 'String'. The type also changed generally.
-print1el :: Bool -> String -> [Result [] Char Double Double] -> IO String
+print1el
+ :: Bool
+ -> String
+ -> [Result [] Char Double Double]
+ -> IO String
 print1el jstlines choice y
  | jstlines == True = putStrLn us >> return us
  | otherwise = putStrLn zs >> return zs
diff --git a/Phonetic/Languages/Simplified/Array/Ukrainian/FuncRep2RelatedG2.hs b/Phonetic/Languages/Simplified/Array/Ukrainian/FuncRep2RelatedG2.hs
--- a/Phonetic/Languages/Simplified/Array/Ukrainian/FuncRep2RelatedG2.hs
+++ b/Phonetic/Languages/Simplified/Array/Ukrainian/FuncRep2RelatedG2.hs
@@ -19,8 +19,24 @@
 -- | Allows to choose the variant of the computations in case of usual processment.
 chooseMax :: (Ord c) => (Double -> c) -> Coeffs2 -> String -> FuncRep2 String Double c
 chooseMax g coeffs choice
- | take 1 choice `elem` ["c","C","N"] = procRhythmicity23F 1.3 g choice coeffs
- | getBFstL' False (zip ["02y","02z","03y","03z","04y","04z","0y","0z","S01","S02","S03","S04","S11",
+ | take 1 choice `elem` ["c","B","C","M","N"] = procRhythmicity23F 1.3 g choice coeffs
+ | getBFstL' False (zip ["02y","02z","03y","03z","04y","04z","0y","0z","I01","I02","I03","I04","I11",
+        "I12","I12","I13","I14","I21","I22","I23","I24","I31","I32","I33","I34","I41","I42","I43","I44",
+        "I51","I52","I53","I54","I61","I62","I63","I64","I71","I72","I74","J01","J02","J03","J04","J11",
+        "J12","J13","J14","J21","J22","J23","J24","J31","J32","J33","J34","J41","J42","J43","J44","J51",
+        "J52","J53","J54","J61","J62","J63","J64","J71","J72","J73","J74","K01","K02","K03","K04","K11",
+        "K12","K13","K14","K21","K21","K22","K23","K24","K31","K32","K33","K34","K41","K42","K43","K44",
+        "K51","K52","K53","K54","K61","K62","K63","K64","K71","K72","K73","K74","L01","L02","L03","L04",
+        "L11","L12","L13","L14","L21","L22","L23","L24","L31","L32","L33","L34","L41","L42","L43","L44",
+        "L51","L52","L53","L54","L61","L62","L63","L64","L71","L72","L74","O01","O02","O03","O04","O11",
+        "O12","O13","O14","O21","O22","O23","O24","O31","O32","O33","O34","O41","O42","O43","O44","O51",
+        "O52","O53","O54","O61","O62","O63","O64","O71","O72","O73","O74","P01","P02","P03","P04","P11",
+        "P12","P13","P14","P21","P22","P23","P24","P31","P32","P33","P34","P41","P42","P43","P44","P51",
+        "P52","P53","P54","P61","P62","P63","P64","P71","P72","P73","P74","Q01","Q02","Q03","Q04",
+        "Q11","Q12","Q13","Q14","Q21","Q22","Q23","Q24","Q31","Q32","Q33","Q34","Q41","Q42","Q43","Q44",
+        "Q51","Q52","Q53","Q54","Q61","Q62","Q63","Q64","Q71","Q72","Q74","R01","R02","R03","R04","R11",
+        "R12","R13","R14","R21","R22","R23","R24","R31","R32","R33","R34","R41","R42","R43","R44","R51",
+        "R52","R53","R54","R61","R62","R63","R64","R71","R72","R73","R74","S01","S02","S03","S04","S11",
         "S12","S12","S13","S14","S21","S22","S23","S24","S31","S32","S33","S34","S41","S42","S43","S44",
         "S51","S52","S53","S54","S61","S62","S63","S64","S71","S72","S74","T01","T02","T03","T04","T11",
         "T12","T13","T14","T21","T22","T23","T24","T31","T32","T33","T34","T41","T42","T43","T44","T51",
@@ -46,7 +62,7 @@
         "v11","v12","v13","v14","v21","v22","v23","v24","v31","v32","v33","v34","v41","v42","v43","v44",
         "v51","v52","v53","v54","v61","v62","v63","v64","v71","v72","v74","w01","w02","w03","w04","w11",
         "w12","w13","w14","w21","w22","w23","w24","w31","w32","w33","w34","x01","x02","x03","x04","x11",
-        "x12","x13","x14","x21","x22","x23","x24","x31","x32","x33","x34"] . replicate 2000 $ True) choice =
+        "x12","x13","x14","x21","x22","x23","x24","x31","x32","x33","x34"] . replicate 3000 $ True) choice =
            procRhythmicity23F 1.3 g choice coeffs
  | otherwise = getBFstL' (procBoth4InvF g coeffs) [("y",procBothF g coeffs),("y0",procDiverse2F g),
                   ("y2",procBoth2F g coeffs),("y3",procBoth3F g coeffs), ("y4",procBoth4F g coeffs),
@@ -55,9 +71,6 @@
                   ("z3",procBoth3FF 1.3 g coeffs), ("z4",procBoth4FF 1.3 g coeffs),
                   ("zz",procBothInvFF 1.3 g coeffs),("zz2",procBoth2InvFF 1.3 g coeffs),
                   ("zz3",procBoth3InvFF 1.3 g coeffs),("zz4", procBoth4InvFF 1.3 g coeffs)] choice
-
-
-
 
 -- | Allows to choose precision in the Numeric.showFDouble function being given a choice parameter.
 precChoice :: String -> Maybe Int
diff --git a/README b/README
--- a/README
+++ b/README
@@ -2,11 +2,11 @@
 of the package phonetic-languages-simplified-examples-array
 in Ukrainian is here:
 
-https://web.archive.org/web/20210814201924/https://oleksandrzhabenko.github.io/uk/Instruction_phonetic-languages-simplified-examples-array-0.8.0.0.pdf
+https://web.archive.org/web/20210816195530/https://oleksandrzhabenko.github.io/uk/Instruction_phonetic-languages-simplified-examples-array-0.9.0.0.pdf
 
 The instruction in English is here:
 
-https://web.archive.org/web/20210814202129/https://oleksandrzhabenko.github.io/uk/Eng-Ukrainian_as_a_Phonetic_Language_Instructions-0.8.0.0.pdf
+https://web.archive.org/web/20210816195650/https://oleksandrzhabenko.github.io/uk/Eng-Ukrainian_as_a_Phonetic_Language_Instructions-0.9.0.0.pdf
 
 Since the version 0.2.0.0 there exists also comparative
 mode for the rewritePoemG3 executable. It allows to
@@ -124,3 +124,8 @@
 rewritePoemG3 +c <file1> <file2> <file3> (all the files must be different and simultaneously the first two ones must
 exist already with some text, otherwise, the program gives no meaningful result).
 
+Since the 0.9.0.0 version there is a possibility to run
+lineVariantsG3 in the recursive mode. It is not
+compatible with the contstraints so should be used not
+simultaneously with them (because they change their
+meaning).
diff --git a/Simple/Main.hs b/Simple/Main.hs
--- a/Simple/Main.hs
+++ b/Simple/Main.hs
@@ -24,19 +24,21 @@
 -- values of the metrics interval using the 'unsafeSwapVecIWithMaxI' function. The first textual command line argument should be in the form either \"y0\",
 -- or \"0y\", or \"yy\", or \"y\", or \"02y\", or \"y2\", or \"03y\", or \"yy2\", or \"y3\", or some other variant and specifies, which property or properties is or are evaluated.
 -- The rest of the command line arguments is the Ukrainian text. Besides, you can use multiple metrices (no more than 5 different ones) together by
--- using \"+M\" ... \"-M\" command line arguments.
+-- using \"+m\" ... \"-m\" command line arguments.
 --
--- You can specify constraints according to the 'decodeLConstraints' function between +A and -A command line arguments. If so, the program will
--- ask you additional question before proceeding. The \"+M\" ... \"-M\" and \"+A\" ... \"-A\" groups must not mutually intersect one another.
+-- You can specify constraints according to the 'decodeLConstraints' function between +a and -a command line arguments. If so, the program will
+-- ask you additional question before proceeding. The \"+m\" ... \"-m\" and \"+a\" ... \"-a\" groups must not mutually intersect one another.
 main :: IO ()
 main = do
- args00 <- getArgs
- let args0 = filter (\xs -> take 2 xs /= "+x" && xs /= "+b" && xs /= "+l" && xs /= "+bl" && xs /= "+i" && xs /= "+u") args00
-     lstW = if any (\x -> x == "+b" || x == "+bl") args00 then True else False -- If one of the command line options is \"+B\" or \"+bl\" then the last word of the line will remain the last one.
-     jstL0 = if any (\x -> x == "+l" || x == "+bl") args00 then True else False -- If one of the command line options is \"+L\" or \"+bl\" then the program outputs just lines without metrices values.
+ args000 <- getArgs
+ let args00 = filter (/= "+r") args000
+     recursiveMode = any (== "+r") args000 -- Specifies whether to use the interactive recursive mode
+     args0 = filter (\xs -> take 2 xs /= "+x" && xs /= "+b" && xs /= "+l" && xs /= "+bl" && xs /= "+i" && xs /= "+u") args00
+     lstW = if any (\x -> x == "+b" || x == "+bl") args00 then True else False -- If one of the command line options is \"+b\" or \"+bl\" then the last word of the line will remain the last one.
+     jstL0 = if any (\x -> x == "+l" || x == "+bl") args00 then True else False -- If one of the command line options is \"+l\" or \"+bl\" then the program outputs just lines without metrices values.
      nativeUkrainian = if any (== "+u") args00 then True else False -- If one of the command line options is \"+u\" then the informational messages are printed in Ukrainian, otherwise (the default behaviour) they are in English.
      toFileMode1 = concat . take 1 . drop 1 . dropWhile (/= "+f") $ args0  -- Prints the last resulting line of the interactive mode processment (the last selected variant) to the file and also to the stdout.
-     interactiveP = if any (\xs -> xs == "+i" || xs == "+f") args00 then True else False -- If one of the command line options is \"+i\", or \"+f\" then the program prints the variants and then prompts for the preferred variant. Afterwards, it prints just that variant alone.
+     interactiveP = recursiveMode || if any (\xs -> xs == "+i" || xs == "+f") args00 then True else False -- If one of the command line options is \"+i\", or \"+f\" then the program prints the variants and then prompts for the preferred variant. Afterwards, it prints just that variant alone.
      args01 = takeWhile (/= "+a") args0 `mappend` (drop 1 . dropWhile (/= "-a") $ args0)
      args02
       | null toFileMode1 = filter (/= "+f") args01
@@ -45,5 +47,5 @@
      args = takeWhile (/= "+m") args02 `mappend` (drop 1 . dropWhile (/= "-m") $ args02)
      coeffs = readCF . concat . take 1 $ args -- The first command line argument.
      coeffsWX = readCF . drop 2 . concat . take 1 . filter (\xs -> take 2 xs == "+x") $ args00 -- The command line argument that starts with \"+x\".
- if isPair coeffs then generalProc2G nativeUkrainian toFileMode1 interactiveP jstL0 args0 coeffs coeffsWX (drop 1 args) lstW
- else generalProc2G nativeUkrainian toFileMode1 interactiveP jstL0 args0 coeffs coeffsWX args lstW
+ if isPair coeffs then generalProc2G recursiveMode nativeUkrainian toFileMode1 interactiveP jstL0 args0 coeffs coeffsWX (drop 1 args) lstW
+ else generalProc2G recursiveMode nativeUkrainian toFileMode1 interactiveP jstL0 args0 coeffs coeffsWX args lstW
diff --git a/phonetic-languages-simplified-examples-array.cabal b/phonetic-languages-simplified-examples-array.cabal
--- a/phonetic-languages-simplified-examples-array.cabal
+++ b/phonetic-languages-simplified-examples-array.cabal
@@ -2,7 +2,7 @@
 -- further documentation, see http://haskell.org/cabal/users-guide/
 
 name:                phonetic-languages-simplified-examples-array
-version:             0.8.1.0
+version:             0.9.0.0
 synopsis:            Helps to create Ukrainian texts with the given phonetic properties.
 description:         Uses more functionality of the arrays and lists. The vector-related functionality is removed and this made the executables and libraries much more lightweight. Deal the Ukrainian as one of the phonetic languages. For the brief introduction in English, please, refer to: https://functional-art.org/2020/papers/Poetry-OleksandrZhabenko.pdf. Since the version 0.3.0.0 the package has the multiple variations mode for @lineVariantsG3@ executable that allows to use modifications in the text, e. g. synonyms, paraphrases etc.
 homepage:            https://hackage.haskell.org/package/phonetic-languages-simplified-examples-array
@@ -20,7 +20,7 @@
   exposed-modules:     Phonetic.Languages.Simplified.Array.Ukrainian.FuncRep2RelatedG2, Phonetic.Languages.Simple, Phonetic.Languages.Lines, Phonetic.Languages.GetTextualInfo, Phonetic.Languages.Parsing
   -- other-modules:
   other-extensions:    BangPatterns
-  build-depends:       base >=4.8 && <4.15, ukrainian-phonetics-basic-array >=0.1.2 && <1, phonetic-languages-simplified-base >=0.1 && <1, phonetic-languages-simplified-properties-array >=0.6 && <1, phonetic-languages-ukrainian-array >=0.2.1 && <1, phonetic-languages-filters-array >=0.1 && <1, uniqueness-periods-vector-stats >=0.2.1 && <1, parallel >=3.2.0.6 && <4, phonetic-languages-plus >=0.2 && <1, subG >= 0.4 && < 1, phonetic-languages-rhythmicity >=0.7 && <1, phonetic-languages-permutations-array >= 0.1 && <1, heaps >= 0.3.6.1 && <1, phonetic-languages-constraints-array >=0.1 && <1, phonetic-languages-simplified-examples-common >=0.1.1 && <1, mmsyn2-array >= 0.1.3 && <1
+  build-depends:       base >=4.8 && <4.15, ukrainian-phonetics-basic-array >=0.1.2 && <1, phonetic-languages-simplified-base >=0.1 && <1, phonetic-languages-simplified-properties-array >=0.7 && <1, phonetic-languages-ukrainian-array >=0.2.1 && <1, phonetic-languages-filters-array >=0.1 && <1, uniqueness-periods-vector-stats >=0.2.1 && <1, parallel >=3.2.0.6 && <4, phonetic-languages-plus >=0.2 && <1, subG >= 0.4 && < 1, phonetic-languages-rhythmicity >=0.8 && <1, phonetic-languages-permutations-array >= 0.1 && <1, heaps >= 0.3.6.1 && <1, phonetic-languages-constraints-array >=0.1 && <1, phonetic-languages-simplified-examples-common >=0.1.1 && <1, mmsyn2-array >= 0.1.3 && <1, string-interpreter >=0.2 && <1
   -- hs-source-dirs:
   default-language:    Haskell2010
 
@@ -28,7 +28,7 @@
   main-is:             Main.hs
   other-modules:       Phonetic.Languages.Simplified.Array.Ukrainian.FuncRep2RelatedG2, Phonetic.Languages.Simple, Phonetic.Languages.Parsing
   other-extensions:    BangPatterns
-  build-depends:       base >=4.8 && <4.15, ukrainian-phonetics-basic-array >=0.1.2 && <1, phonetic-languages-simplified-base >=0.1 && <1, phonetic-languages-simplified-properties-array >=0.6 && <1, phonetic-languages-ukrainian-array >=0.2.1 && <1, phonetic-languages-filters-array >=0.1 && <1, phonetic-languages-plus >=0.2 && <1, subG >=0.4 && < 1, mmsyn2-array >= 0.1.3 && <1, phonetic-languages-constraints-array >=0.1 && <1, phonetic-languages-permutations-array >= 0.1 && <1, heaps >= 0.3.6.1 && <1, phonetic-languages-simplified-examples-common >=0.1.1 && <1
+  build-depends:       base >=4.8 && <4.15, ukrainian-phonetics-basic-array >=0.1.2 && <1, phonetic-languages-simplified-base >=0.1 && <1, phonetic-languages-simplified-properties-array >=0.7 && <1, phonetic-languages-ukrainian-array >=0.2.1 && <1, phonetic-languages-filters-array >=0.1 && <1, phonetic-languages-plus >=0.2 && <1, subG >=0.4 && < 1, mmsyn2-array >= 0.1.3 && <1, phonetic-languages-constraints-array >=0.1 && <1, phonetic-languages-permutations-array >= 0.1 && <1, heaps >= 0.3.6.1 && <1, phonetic-languages-simplified-examples-common >=0.1.1 && <1, string-interpreter >=0.2 && <1
   ghc-options:         -threaded -rtsopts
   hs-source-dirs:      ., Simple
   default-language:    Haskell2010
@@ -37,7 +37,7 @@
   main-is:             Main.hs
   other-modules:       Phonetic.Languages.Simplified.Array.Ukrainian.FuncRep2RelatedG2, Phonetic.Languages.Lines, Phonetic.Languages.Parsing
   other-extensions:    BangPatterns
-  build-depends:       base >=4.8 && <4.15, ukrainian-phonetics-basic-array >=0.1.2 && <1, phonetic-languages-simplified-base >=0.1 && <1, phonetic-languages-simplified-properties-array >=0.6 && <1, phonetic-languages-ukrainian-array >=0.2.1 && <1, phonetic-languages-filters-array >=0.1 && <1, phonetic-languages-plus >=0.2 && <1, subG >= 0.4 && < 1, phonetic-languages-rhythmicity >=0.7 && <1, phonetic-languages-constraints-array >=0.1 && <1, phonetic-languages-permutations-array >= 0.1 && <1, heaps >= 0.3.6.1 && <1, phonetic-languages-simplified-examples-common >=0.1.1 && <1, mmsyn2-array >= 0.1.3 && <1
+  build-depends:       base >=4.8 && <4.15, ukrainian-phonetics-basic-array >=0.1.2 && <1, phonetic-languages-simplified-base >=0.1 && <1, phonetic-languages-simplified-properties-array >=0.7 && <1, phonetic-languages-ukrainian-array >=0.2.1 && <1, phonetic-languages-filters-array >=0.1 && <1, phonetic-languages-plus >=0.2 && <1, subG >= 0.4 && < 1, phonetic-languages-rhythmicity >=0.8 && <1, phonetic-languages-constraints-array >=0.1 && <1, phonetic-languages-permutations-array >= 0.1 && <1, heaps >= 0.3.6.1 && <1, phonetic-languages-simplified-examples-common >=0.1.1 && <1, mmsyn2-array >= 0.1.3 && <1
   ghc-options:         -threaded -rtsopts
   hs-source-dirs:      ., Lines
   default-language:    Haskell2010
@@ -46,7 +46,7 @@
   main-is:             Main.hs
   other-modules:       Phonetic.Languages.Simplified.Array.Ukrainian.FuncRep2RelatedG2, Phonetic.Languages.GetTextualInfo, Phonetic.Languages.Parsing
   other-extensions:    BangPatterns
-  build-depends:       base >=4.8 && <4.15, ukrainian-phonetics-basic-array >=0.1.2 && <1, phonetic-languages-simplified-base >=0.1 && <1, phonetic-languages-simplified-properties-array >=0.6 && <1, phonetic-languages-ukrainian-array >=0.2.1 && <1, phonetic-languages-filters-array >=0.1 && <1, uniqueness-periods-vector-stats >=0.2.1 && <1, parallel >=3.2.0.6 && <4, phonetic-languages-plus >=0.2 && <1, subG >= 0.4 && < 1, phonetic-languages-rhythmicity >=0.7 && <1, phonetic-languages-permutations-array >= 0.1 && <1, heaps >= 0.3.6.1 && <1, phonetic-languages-constraints-array >=0.1 && <1, phonetic-languages-simplified-examples-common >=0.1.1 && <1, mmsyn2-array >= 0.1.3 && <1
+  build-depends:       base >=4.8 && <4.15, ukrainian-phonetics-basic-array >=0.1.2 && <1, phonetic-languages-simplified-base >=0.1 && <1, phonetic-languages-simplified-properties-array >=0.7 && <1, phonetic-languages-ukrainian-array >=0.2.1 && <1, phonetic-languages-filters-array >=0.1 && <1, uniqueness-periods-vector-stats >=0.2.1 && <1, parallel >=3.2.0.6 && <4, phonetic-languages-plus >=0.2 && <1, subG >= 0.4 && < 1, phonetic-languages-rhythmicity >=0.8 && <1, phonetic-languages-permutations-array >= 0.1 && <1, heaps >= 0.3.6.1 && <1, phonetic-languages-constraints-array >=0.1 && <1, phonetic-languages-simplified-examples-common >=0.1.1 && <1, mmsyn2-array >= 0.1.3 && <1
   ghc-options:         -threaded -rtsopts
   hs-source-dirs:      ., GetInfo
   default-language:    Haskell2010