diff --git a/CHANGELOG.md b/CHANGELOG.md
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -260,3 +260,14 @@
 The theoretical part of this document has been improved. Fixed some code bugs. Switched in calculations of the
 average values and standard deviation from population to sample versions (now the standard deviation is slightly higher).
 Fixed issues with multiple variations of the text mode if it is not used interactively.
+
+## 0.20.0.0 -- 2022-08-09
+
+* The twentieth version. Updated the dependencies so that now the Ukrainian syllable segmentation is treated more properly.
+Changed the structure of the non-sound Ukraninian symbols representation (now they are converted to one of the [100,101,102]).
+Switched to the new Result2 representation. Added the new syllables-as-a-whole functionality 
+to deal with e.g. syllabo-tonic verses. Added the possibility to print more verbose output
+in the multiple properties mode for lineVariantsG3 executable. All these changes lead to
+the need to recompute the values if they are important and not the result. Updated the
+documentation with the new data.
+
diff --git a/Phonetic/Languages/GetTextualInfo.hs b/Phonetic/Languages/GetTextualInfo.hs
--- a/Phonetic/Languages/GetTextualInfo.hs
+++ b/Phonetic/Languages/GetTextualInfo.hs
@@ -52,6 +52,7 @@
 import Phonetic.Languages.Simplified.Array.Ukrainian.ReadProperties
 import Phonetic.Languages.Permutations.Represent
 import Languages.Ukrainian.Data
+import Phonetic.Languages.Emphasis
 
 {-| @ since 0.5.0.0 -- The meaning of the first command line argument (and 'Coeffs2' here everywhere in the module)
 depends on the 'String' argument -- whether it starts with \'w\', \'x\' or otherwise. In the first case it represents
@@ -114,7 +115,7 @@
  -> [String]
  -> [String]
  -> IO ()
-getData3 syllableDurationsDs pairwisePermutations lstW coeffs coeffsWX gz printLine choice multiples3 zss = let !permsV4 = case pairwisePermutations of { Phonetic.Languages.Permutations.Represent.P 2 -> genPairwisePermutationsArrLN 10; Phonetic.Languages.Permutations.Represent.P 1 -> genElementaryPermutationsArrLN1 10; ~rrr -> genPermutationsArrL } in putStrLn (replicate (length multiples3 + 1) '\t' `mappend` show gz) >> mapM_ (process1Line syllableDurationsDs lstW coeffs coeffsWX gz printLine choice multiples3 permsV4) zss
+getData3 syllableDurationsDs pairwisePermutations lstW coeffs coeffsWX gz printLine choice0 multiples3 zss = let choice = filter (/= 'a') choice0 in let !permsV4 = case pairwisePermutations of { Phonetic.Languages.Permutations.Represent.P 2 -> genPairwisePermutationsArrLN 10; Phonetic.Languages.Permutations.Represent.P 1 -> genElementaryPermutationsArrLN1 10; ~rrr -> genPermutationsArrL } in putStrLn (replicate (length multiples3 + 1) '\t' `mappend` show gz) >> mapM_ (process1Line syllableDurationsDs lstW coeffs coeffsWX gz printLine choice multiples3 permsV4) zss
 
 process1Line
  :: [[[[Sound8]]] -> [[Double]]] -- ^ Whether to use the own provided durations.
@@ -136,13 +137,13 @@
      if l2 >= (if lstW then 1 else 0) then do
       let !permsV5 = decodeConstraint1 (fromMaybe (E 1) . readMaybeECG (l2 + 1) . showB (l2 + 2) $ lstW) .
             unsafeAt permsV50 $ l2
-          ((!minE,!maxE),!data2) = runEval (parTuple2 rpar rpar (minMax11C . map (toTransPropertiesF' (if take 1 choice == "x"
+          ((!minE,!maxE),!data2) = runEval (parTuple2 rpar rpar (minMax11C . map (toTransPropertiesF'2 (if take 1 choice == "x"
             || take 1 choice == "w" || (take 1 choice == "H" && (drop 1 (take 2 choice) `elem` ["w","x"]))
-              then chooseMax tup1 tup2 tup3 tup4 tup5 tup6 tup7 tup8 tup9 tup10 tup11 tup12 tup13 tup14 tup15 tup16 tup17 syllableDurationsDs id coeffsWX choice
-              else chooseMax tup1 tup2 tup3 tup4 tup5 tup6 tup7 tup8 tup9 tup10 tup11 tup12 tup13 tup14 tup15 tup16 tup17 syllableDurationsDs id coeffs choice)) .
-                uniquenessVariants2GNBL ' ' id id id permsV5 $ v2, toTransPropertiesF' (if take 1 choice == "x"
-                  || take 1 choice == "w" then chooseMax tup1 tup2 tup3 tup4 tup5 tup6 tup7 tup8 tup9 tup10 tup11 tup12 tup13 tup14 tup15 tup16 tup17 syllableDurationsDs id coeffsWX choice
-                    else chooseMax tup1 tup2 tup3 tup4 tup5 tup6 tup7 tup8 tup9 tup10 tup11 tup12 tup13 tup14 tup15 tup16 tup17 syllableDurationsDs id coeffs choice) . unwords . subG " 01-" $ v))
+              then chooseMax tup1 tup2 tup3 tup4 tup5 tup6 tup7 tup8 tup9 tup10 tup11 tup12 tup13 tup14 tup15 tup16 tup17 syllableDurationsDs id coeffsWX choice ""
+              else chooseMax tup1 tup2 tup3 tup4 tup5 tup6 tup7 tup8 tup9 tup10 tup11 tup12 tup13 tup14 tup15 tup16 tup17 syllableDurationsDs id coeffs choice "")) .
+                map Str . uniquenessVariants2GNBL ' ' id id id permsV5 $ v2, toTransPropertiesF'2 (if take 1 choice == "x"
+                  || take 1 choice == "w" then chooseMax tup1 tup2 tup3 tup4 tup5 tup6 tup7 tup8 tup9 tup10 tup11 tup12 tup13 tup14 tup15 tup16 tup17 syllableDurationsDs id coeffsWX choice ""
+                    else chooseMax tup1 tup2 tup3 tup4 tup5 tup6 tup7 tup8 tup9 tup10 tup11 tup12 tup13 tup14 tup15 tup16 tup17 syllableDurationsDs id coeffs choice "") . Str . unwords . subG " " $ v))
           (!wordsN,!intervalN) = (l2 + 2, intervalNRealFrac minE maxE gz data2)
           !ratio = if maxE == 0.0 then 0.0 else 2.0 * data2 / (minE + maxE)
       hPutStr stdout . showFFloat (precChoice choice) minE $ "\t"
@@ -165,16 +166,16 @@
      let !permsV5 = decodeConstraint1 (fromMaybe (E 1) . readMaybeECG (l2 + 1) . showB (l2 + 2) $ lstW) .
             unsafeAt permsV50 $ l2
          rs = parMap rpar (\choiceMMs -> (minMax11C .
-           map (toTransPropertiesF' (if take 1 choiceMMs == "x" || take 1 choiceMMs == "w" ||
+           map (toTransPropertiesF'2 (if take 1 choiceMMs == "x" || take 1 choiceMMs == "w" ||
             (take 1 choice == "H" && (drop 1 (take 2 choice) `elem` ["w","x"]))
-             then chooseMax tup1 tup2 tup3 tup4 tup5 tup6 tup7 tup8 tup9 tup10 tup11 tup12 tup13 tup14 tup15 tup16 tup17 syllableDurationsDs id coeffsWX choiceMMs
-             else chooseMax tup1 tup2 tup3 tup4 tup5 tup6 tup7 tup8 tup9 tup10 tup11 tup12 tup13 tup14 tup15 tup16 tup17 syllableDurationsDs id coeffs choiceMMs)) .
-              uniquenessVariants2GNBL ' ' id id id permsV5 $ v2,
-               toTransPropertiesF' (if take 1 choiceMMs == "x" || take 1 choiceMMs == "w" ||
+             then chooseMax tup1 tup2 tup3 tup4 tup5 tup6 tup7 tup8 tup9 tup10 tup11 tup12 tup13 tup14 tup15 tup16 tup17 syllableDurationsDs id coeffsWX choiceMMs ""
+             else chooseMax tup1 tup2 tup3 tup4 tup5 tup6 tup7 tup8 tup9 tup10 tup11 tup12 tup13 tup14 tup15 tup16 tup17 syllableDurationsDs id coeffs choiceMMs "")) .
+              map Str . uniquenessVariants2GNBL ' ' id id id permsV5 $ v2,
+               toTransPropertiesF'2 (if take 1 choiceMMs == "x" || take 1 choiceMMs == "w" ||
                 (take 1 choice == "H" && (drop 1 (take 2 choice) `elem` ["w","x"]))
-                 then chooseMax tup1 tup2 tup3 tup4 tup5 tup6 tup7 tup8 tup9 tup10 tup11 tup12 tup13 tup14 tup15 tup16 tup17 syllableDurationsDs id coeffsWX choiceMMs
-                 else chooseMax tup1 tup2 tup3 tup4 tup5 tup6 tup7 tup8 tup9 tup10 tup11 tup12 tup13 tup14 tup15 tup16 tup17 syllableDurationsDs id coeffs choiceMMs) .
-                  unwords . subG " 01-" $ v,gz)) multiples4
+                 then chooseMax tup1 tup2 tup3 tup4 tup5 tup6 tup7 tup8 tup9 tup10 tup11 tup12 tup13 tup14 tup15 tup16 tup17 syllableDurationsDs id coeffsWX choiceMMs ""
+                 else chooseMax tup1 tup2 tup3 tup4 tup5 tup6 tup7 tup8 tup9 tup10 tup11 tup12 tup13 tup14 tup15 tup16 tup17 syllableDurationsDs id coeffs choiceMMs "") . Str .
+                  unwords . subG " " $ v,gz)) multiples4
          (!wordsN,!intervalNs) = (l2 + 2, map (\((!x,!y),!z,!t) -> intervalNRealFrac x y t z) rs)
            in do
             hPutStr stdout (show (wordsN::Int))
diff --git a/Phonetic/Languages/Lines.hs b/Phonetic/Languages/Lines.hs
--- a/Phonetic/Languages/Lines.hs
+++ b/Phonetic/Languages/Lines.hs
@@ -39,7 +39,7 @@
 import Phonetic.Languages.Permutations.Represent
 import Languages.Ukrainian.Data
 import Phonetic.Languages.Array.Ukrainian.Common
-
+import Phonetic.Languages.Emphasis
 
 {-| @ since 0.5.0.0 -- The meaning of the first command line argument (and 'Coeffs2' here everywhere in the module)
 depends on the 'String' argument -- whether it starts with \'w\', \'x\' or otherwise. In the first case it represents
@@ -65,8 +65,9 @@
  -> Int
  -> FilePath -- ^ The file with the text in Ukranian to be rewritten.
  -> IO ()
-generalProcessment fileDu pairwisePermutations (gr1,gr2) coeffs numericArgs choices numberI file = do
+generalProcessment fileDu pairwisePermutations (gr1,gr2) coeffs numericArgs choices0 numberI file = do
   syllableDurationsDs <- readSyllableDurations fileDu
+  let choices = map (filter (/='a')) choices0
   contents <- readFile file
   let !permsV
         | pairwisePermutations == P 2 = genPairwisePermutationsArrLN 10
@@ -85,8 +86,8 @@
         !l2 = (subtract 3) . length $ us
     if compare l2 0 /= LT then do
       let !perms2 = unsafeAt permsV $ l2
-          minMaxTuples = let !frep20Zip = zip choices . map (chooseMax tup1 tup2 tup3 tup4 tup5 tup6 tup7 tup8 tup9 tup10 tup11 tup12 tup13 tup14 tup15 tup16 tup17 syllableDurationsDs id coeffs) $ choices in
-            map (\(_,frep20) -> minMax11C . map (toPropertiesF' frep20) .
+          minMaxTuples = let !frep20Zip = zip choices . map (\choice -> chooseMax tup1 tup2 tup3 tup4 tup5 tup6 tup7 tup8 tup9 tup10 tup11 tup12 tup13 tup14 tup15 tup16 tup17 syllableDurationsDs id coeffs choice "") $ choices in
+            map (\(_,frep20) -> minMax11C . map (toPropertiesF'2 frep20 . Str) .
               uniquenessVariants2GNPBL [] (concat . take 1 $ lasts) ' ' id id id perms2 . init $ us) frep20Zip
       mapM_ (\(choice, (minE,maxE)) -> toFileStr (choice ++ "." ++ file ++ ".new.txt")
               (circle2I syllableDurationsDs coeffs permsV choice [] numberI intervalNmbrs minE maxE $
@@ -125,8 +126,8 @@
       where (!zss,!tss) = splitAt 1 xss
             !rs = words . concat $ zss
             !l = length rs
-            !frep2 = chooseMax tup1 tup2 tup3 tup4 tup5 tup6 tup7 tup8 tup9 tup10 tup11 tup12 tup13 tup14 tup15 tup16 tup17 syllableDurationsDs id coeffs choice
-            !ws = if compare l 3 == LT then unwords rs else line . maximumElR . map (toResultR frep2) .
+            !frep2 = chooseMax tup1 tup2 tup3 tup4 tup5 tup6 tup7 tup8 tup9 tup10 tup11 tup12 tup13 tup14 tup15 tup16 tup17 syllableDurationsDs id coeffs choice ""
+            !ws = if compare l 3 == LT then unwords rs else (\rrrr -> fromMaybe "" . fromReadyFCUkrS $ rrrr).  line2 . maximumElR2 . map (toResultR2 frep2 . Str) .
                uniquenessVariants2GNPBL [] (last rs) ' ' id id id (unsafeAt permsG1 (l - 3)) . init $ rs
 
 -- | Processment with rearrangements.
@@ -150,15 +151,15 @@
             !l3 = (subtract 3) . length $ w2s
             !rs = words . concat $ zss
             !l = length rs
-            !frep2 = chooseMax tup1 tup2 tup3 tup4 tup5 tup6 tup7 tup8 tup9 tup10 tup11 tup12 tup13 tup14 tup15 tup16 tup17 syllableDurationsDs (unsafeSwapVecIWithMaxI minE maxE numberI intervNbrs) coeffs choice
-            !ws = if compare (length rs) 3 == LT then unwords rs else line . maximumElR .
-                    map (toResultR frep2) .
+            !frep2 = chooseMax tup1 tup2 tup3 tup4 tup5 tup6 tup7 tup8 tup9 tup10 tup11 tup12 tup13 tup14 tup15 tup16 tup17 syllableDurationsDs (unsafeSwapVecIWithMaxI minE maxE numberI intervNbrs) coeffs choice ""
+            !ws = if compare (length rs) 3 == LT then unwords rs else (\rrrr -> fromMaybe "" . fromReadyFCUkrS $ rrrr).  line2 . maximumElR2 .
+                    map (toResultR2 frep2 . Str) .
                       uniquenessVariants2GNPBL [] (last rs) ' ' id id id (unsafeAt permsG1 (l - 3)) . init $ rs
             (!minE1,!maxE1)
              | compare l3 0 /= LT =
                let !perms3 = unsafeAt permsG1 l3
                    !v4 = init w2s
-                   !frep20 = chooseMax tup1 tup2 tup3 tup4 tup5 tup6 tup7 tup8 tup9 tup10 tup11 tup12 tup13 tup14 tup15 tup16 tup17 syllableDurationsDs id coeffs choice in minMax11C . map (toPropertiesF' frep20) .
+                   !frep20 = chooseMax tup1 tup2 tup3 tup4 tup5 tup6 tup7 tup8 tup9 tup10 tup11 tup12 tup13 tup14 tup15 tup16 tup17 syllableDurationsDs id coeffs choice "" in minMax11C . map (toPropertiesF'2 frep20 . Str) .
                       uniquenessVariants2GNPBL [] (last w2s) ' ' id id id perms3 $ v4
              | otherwise = (0.0,0.0)
 
diff --git a/Phonetic/Languages/Simple.hs b/Phonetic/Languages/Simple.hs
--- a/Phonetic/Languages/Simple.hs
+++ b/Phonetic/Languages/Simple.hs
@@ -1,14 +1,16 @@
 {-# OPTIONS_GHC -threaded -rtsopts #-}
 {-# OPTIONS_HADDOCK show-extensions #-}
 {-# LANGUAGE BangPatterns #-}
+{-# LANGUAGE FlexibleInstances #-}
+{-# LANGUAGE FlexibleContexts #-}
 
+
 -- |
 -- Module      :  Phonetic.Languages.Simple
 -- Copyright   :  (c) OleksandrZhabenko 2020-2022
 -- License     :  MIT
 -- Stability   :  Experimental
 -- Maintainer  :  olexandr543@yahoo.com
---
 -- The library functions for the lineVariantsG3 executable. Since 0.4.0.0 version it supports printing of the informational
 -- messages both in English and Ukrainian. Since the 0.13.0.0 version there is the possibility to provide custom durations
 -- instead of the default predefined ones.
@@ -20,13 +22,14 @@
 import Numeric
 import Languages.UniquenessPeriods.Array.Constraints.Encoded (decodeLConstraints,readMaybeECG)
 import GHC.Arr
+import CaseBi.Arr (getBFstLSorted')
 import Phonetic.Languages.Simplified.DataG.Base
 import Phonetic.Languages.Basis
 import Phonetic.Languages.Simplified.DataG.Partir
 import Phonetic.Languages.Filters (unsafeSwapVecIWithMaxI)
 import Phonetic.Languages.Simplified.StrictVG.Base
 import Data.Char (isDigit,isAlpha,isLetter)
-import qualified Data.List  as L (span,sort,zip4,isPrefixOf,nub)
+import qualified Data.List  as L (span,sort,zip4,isPrefixOf,nub,sortBy,intersperse)
 import Phonetic.Languages.Simplified.Array.Ukrainian.FuncRep2RelatedG2
 import Phonetic.Languages.Permutations.Arr
 import Phonetic.Languages.Permutations.ArrMini
@@ -43,6 +46,8 @@
 import Phonetic.Languages.Simplified.Array.Ukrainian.ReadProperties
 import Phonetic.Languages.Permutations.Represent
 import Languages.Ukrainian.Data
+import Phonetic.Languages.Emphasis
+import Data.List (sortBy)
 
 forMultiplePropertiesF :: [String] -> [(String,[String])]
 forMultiplePropertiesF (xs:xss)
@@ -70,16 +75,19 @@
  -> Coeffs2
  -> [String]
  -> Bool
+ -> Bool -- ^ Whether to use volatile string weights
+ -> Int -- ^ Number of sets of volatile string weights for every processed line. Is used when the previous one is 'True'
+ -> Int -- ^ Whether to print more verbose information in the output with sorting in some way
  -> IO ()
-generalProc3G fileDu pairwisePermutations textProcessmentFss textProcessment0 textProcessment1 recursiveMode nativeUkrainian toFileMode1 interactiveP jstL0 args0 coeffs coeffsWX args lstW = do
+generalProc3G fileDu pairwisePermutations textProcessmentFss textProcessment0 textProcessment1 recursiveMode nativeUkrainian toFileMode1 interactiveP jstL0 args0 coeffs coeffsWX args lstW syllables syllablesVs verbose = do
   syllableDurationsDs <- readSyllableDurations fileDu
-  generalProc3G' syllableDurationsDs pairwisePermutations textProcessmentFss textProcessment0 textProcessment1 recursiveMode nativeUkrainian toFileMode1 interactiveP jstL0 args0 coeffs coeffsWX args lstW
-    where generalProc3G' syllableDurationsDs pairwisePermutations textProcessmentFss textProcessment0 textProcessment1 recursiveMode nativeUkrainian toFileMode1 interactiveP jstL0 args0 coeffs coeffsWX args lstW
-            | null textProcessment0 = generalProc2G syllableDurationsDs pairwisePermutations recursiveMode nativeUkrainian toFileMode1 interactiveP jstL0 args0 coeffs coeffsWX args lstW
+  generalProc3G' syllableDurationsDs pairwisePermutations textProcessmentFss textProcessment0 textProcessment1 recursiveMode nativeUkrainian toFileMode1 interactiveP jstL0 args0 coeffs coeffsWX args lstW syllables syllablesVs verbose
+    where generalProc3G' syllableDurationsDs pairwisePermutations textProcessmentFss textProcessment0 textProcessment1 recursiveMode nativeUkrainian toFileMode1 interactiveP jstL0 args0 coeffs coeffsWX args lstW syllables syllablesVs verbose
+            | null textProcessment0 = generalProc2G syllableDurationsDs pairwisePermutations recursiveMode nativeUkrainian toFileMode1 interactiveP jstL0 args0 coeffs coeffsWX args lstW syllables syllablesVs verbose
             | null textProcessmentFss = mapM_ (\_ -> do  -- interactive training mode
                  putStrLn . messageInfo 7 $ nativeUkrainian
                  lineA <- getLine
-                 generalProc2G syllableDurationsDs pairwisePermutations recursiveMode nativeUkrainian toFileMode1 interactiveP jstL0 (fullArgsConvertTextualSimple mightNotUkrWord lineA args0) coeffs coeffsWX (fullArgsConvertTextualSimple mightNotUkrWord lineA args) lstW) [0..]
+                 generalProc2G syllableDurationsDs pairwisePermutations recursiveMode nativeUkrainian toFileMode1 interactiveP jstL0 (fullArgsConvertTextualSimple mightNotUkrWord lineA args0) coeffs coeffsWX (fullArgsConvertTextualSimple mightNotUkrWord lineA args) lstW  syllables syllablesVs verbose) [0..]
             | otherwise =
                  mapM_ (\js -> do
                   let !kss = lines js
@@ -88,13 +96,13 @@
                          | textProcessment1 `elem` [10,20,30,40,50,60,70,80,90] = kss
                          | otherwise = prepareTuneTextMN m 1 . unwords $ kss
                     mapM_ (\tss -> generalProc2G syllableDurationsDs pairwisePermutations recursiveMode nativeUkrainian toFileMode1 interactiveP jstL0 (fullArgsConvertTextualSimple mightNotUkrWord tss args0) coeffs coeffsWX
-                      (fullArgsConvertTextualSimple mightNotUkrWord tss args) lstW) wss
+                      (fullArgsConvertTextualSimple mightNotUkrWord tss args) lstW syllables syllablesVs verbose) wss
                   else do
                     let !wss
                          | textProcessment1 `elem` [20,30,40,50,60,70] = kss
                          | otherwise = prepareTuneTextMN (if textProcessment1 `elem` [21,31,41,51,61] then m else 7) 1 . unwords $ kss
                     mapM_ (\tss -> generalProc2G syllableDurationsDs pairwisePermutations recursiveMode nativeUkrainian toFileMode1 interactiveP jstL0 (fullArgsConvertTextualSimple mightNotUkrWord tss args0) coeffs coeffsWX
-                      (fullArgsConvertTextualSimple mightNotUkrWord tss args) lstW) wss) textProcessmentFss
+                      (fullArgsConvertTextualSimple mightNotUkrWord tss args) lstW syllables syllablesVs verbose) wss) textProcessmentFss
           m = if textProcessment1 == 10 || textProcessment1 == 11 then 10 else quot textProcessment1 10
 
 {-| If 'False' then it might be the Ukrainian word in the phonetic languages approach. If 'True', it is not.
@@ -140,28 +148,32 @@
  -> Coeffs2
  -> [String]
  -> Bool
+ -> Bool -- ^ Whether to use volatile string weights
+ -> Int -- ^ Number of sets of volatile string weights for every processed line. Is used when the previous one is 'True'
+ -> Int 
  -> IO ()
-generalProc2G syllableDurationsDs pairwisePermutations recursiveMode nativeUkrainian toFile1 interactive jstL0 args0 coeffs coeffsWX args lstW2
+generalProc2G syllableDurationsDs pairwisePermutations recursiveMode nativeUkrainian toFile1 interactive jstL0 args0 coeffs coeffsWX args lstW2 syllables syllablesVs verbose
  | variations args = do
     let !zsss = transformToVariations args
-    variantsG <- mapM (\xss -> generalProc2 syllableDurationsDs pairwisePermutations recursiveMode nativeUkrainian interactive jstL0 args0 coeffs coeffsWX xss lstW2) zsss
+    variantsG <- mapM (\xss -> generalProc2 syllableDurationsDs [] pairwisePermutations recursiveMode nativeUkrainian interactive jstL0 args0 coeffs coeffsWX xss lstW2 syllables syllablesVs verbose) zsss
     if interactive then do 
-           (if recursiveMode then interactivePrintResultRecursive syllableDurationsDs pairwisePermutations recursiveMode nativeUkrainian interactive jstL0  args0 coeffs coeffsWX id variantsG args lstW2
-           else interactivePrintResult nativeUkrainian id variantsG) >>= \rs ->
+           (if recursiveMode then interactivePrintResultRecursive syllableDurationsDs [] pairwisePermutations recursiveMode nativeUkrainian interactive jstL0  args0 coeffs coeffsWX (showR . fst) variantsG args lstW2 syllables syllablesVs verbose
+           else interactivePrintResult nativeUkrainian (showR . fst) variantsG syllables syllablesVs) >>= \(rs,cs) ->
             case toFile1 of
                "" -> return ()
-               ~fileName -> appendFile fileName (rs `mappend` newLineEnding)
+               ~fileName -> appendFile fileName (convFSL cs rs `mappend` newLineEnding)
     else return () 
- | otherwise = generalProc2 syllableDurationsDs pairwisePermutations recursiveMode nativeUkrainian interactive jstL0 args0 coeffs coeffsWX args lstW2 >>=
-    \rs ->
+ | otherwise = generalProc2 syllableDurationsDs [] pairwisePermutations recursiveMode nativeUkrainian interactive jstL0 args0 coeffs coeffsWX args lstW2 syllables syllablesVs verbose >>=
+    \(rs,cs) ->
       case toFile1 of
        "" -> return ()
-       ~fileName -> appendFile fileName (rs `mappend` newLineEnding)
+       ~fileName -> appendFile fileName (convFSL cs rs `mappend` newLineEnding)
 
 -- |
 -- @ since 0.3.0.0 The result is not 'IO' (), but 'IO' 'String'. The type also changed generally.
 generalProc2
  :: [[[[Sound8]]] -> [[Double]]] -- ^ Whether to use the own provided durations.
+ -> [[[[Sound8]]] -> [[Double]]] -- ^ Whether to use the volatile syllables durations
  -> PermutationsType -- ^ Whether to use just one of the express permutations, or the full universal set.
  -> Bool
  -> Bool
@@ -172,44 +184,48 @@
  -> Coeffs2
  -> [String]
  -> Bool
- -> IO String
-generalProc2 syllableDurationsDs pairwisePermutations recursiveMode nativeUkrainian interactive jstL0 args0 coeffs coeffsWX args lstW2 = do
-  let !argMss = take 5 . filter (not . null) . forMultiplePropertiesF . drop 1 . dropWhile (/= "+m") .
+ -> Bool -- ^ Whether to use volatile string weights
+ -> Int -- ^ Number of sets of volatile string weights for every processed line. Is used when the previous one is 'True'
+ -> Int
+ -> IO (ReadyForConstructionUkr, String)
+generalProc2 syllableDurationsDs sDs pairwisePermutations recursiveMode nativeUkrainian interactive jstL0 args0 coeffs coeffsWX args lstW2 syllables syllablesVs verbose = 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
-       !xs = concat . take 1 . prepareTuneTextMN (if pairwisePermutations /= P 0 then 10 else 7) 1 . unwords . drop 1 $ textualArgs
-       !l = length . words $ xs
-       !argCs = catMaybes (fmap (readMaybeECG (l - 1)) . (showB l lstW2:) . drop 1 . dropWhile (/= "+a") .
-                  takeWhile (/= "-a") $ args0)
-       !arg0 = concat . take 1 $ numericArgs
-       !numberI = fromMaybe 1 $ (readMaybe (concat . drop 1 . take 2 $ numericArgs)::Maybe Int)
-       !choice = concat . take 1 $ textualArgs
-       !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
-                                    | take 1 choice == "x" || take 1 choice == "w" || (take 1 choice == "H" && (drop 1 (take 2 choice) `elem` ["x","w"]))= chooseMax tup1 tup2 tup3 tup4 tup5 tup6 tup7 tup8 tup9 tup10 tup11 tup12 tup13 tup14 tup15 tup16 tup17 syllableDurationsDs id coeffsWX choice
-                                    | otherwise = chooseMax tup1 tup2 tup3 tup4 tup5 tup6 tup7 tup8 tup9 tup10 tup11 tup12 tup13 tup14 tup15 tup16 tup17 syllableDurationsDs id coeffs choice
-                                 !wwss = (:[]) . toResultR frep20 $ xs in
+ if null argMss then do
+  let (!numericArgs,!textualArgs) = L.span (all isDigit) $ args
+      !bs = concat . take 1 . prepareTuneTextMN (if pairwisePermutations /= P 0 then 10 else 7) 1 . unwords . drop 1 $ textualArgs
+      !xs = Str bs
+      !l = length . words $ bs
+      !argCs = catMaybes (fmap (readMaybeECG (l - 1)) . (showB l lstW2:) . drop 1 . dropWhile (/= "+a") .
+                 takeWhile (/= "-a") $ args0)
+      !arg0 = concat . take 1 $ numericArgs
+      !numberI = fromMaybe 1 $ (readMaybe (concat . drop 1 . take 2 $ numericArgs)::Maybe Int)
+      !choice = concat . take 1 $ textualArgs
+      !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 syllables then do weightsString3NIO syllablesVs (any (== 'a') choice) bs else return ([],[],Str [])) >>= \(syllDs,syllableDs,readys) -> do 
+   if compare l 2 == LT then let !frep20 = chooseMax tup1 tup2 tup3 tup4 tup5 tup6 tup7 tup8 tup9 tup10 tup11 tup12 tup13 tup14 tup15 tup16 tup17 (if any (== 'a') choice then syllableDs else syllableDurationsDs) id (if any (\t -> t == 'x' || t == 'w') choice then coeffsWX else  coeffs) choice bs
+                                 !wwss = (:[]) . toResultR2 frep20 $ xs in
     case recursiveMode of
-      True -> interactivePrintResultRecursive syllableDurationsDs pairwisePermutations recursiveMode nativeUkrainian interactive jstL0 args0 coeffs coeffsWX line wwss args lstW2
-      _ -> if interactive then interactivePrintResult nativeUkrainian line wwss else print1el jstL0 choice wwss
+      True -> interactivePrintResultRecursive syllableDurationsDs (if any (== 'a') choice then syllableDs else sDs) pairwisePermutations recursiveMode nativeUkrainian interactive jstL0 args0 coeffs coeffsWX (convFSL bs . line2) wwss args lstW2 syllables syllablesVs verbose
+      _ -> if interactive then interactivePrintResult nativeUkrainian (convFSL bs . line2) wwss syllables syllablesVs else print1el jstL0 choice wwss
    else do
-    let !subs = subG " 01-" xs
+    let !subs = subG " " bs -- Probably, here it can just 'words' be used.
     if null argCs then let !perms
                              | pairwisePermutations == P 2 = genPairwisePermutationsLN l
                              | pairwisePermutations == P 1 = genElementaryPermutationsLN1 l
                              | otherwise = genPermutationsL l in do
-          temp <- generalProcMs syllableDurationsDs coeffs coeffsWX perms subs (intervalNmbrs, arg0, numberI, choice)
-          if recursiveMode then interactivePrintResultRecursive syllableDurationsDs pairwisePermutations recursiveMode nativeUkrainian interactive jstL0 args0 coeffs coeffsWX line temp args lstW2
-          else if interactive then interactivePrintResult nativeUkrainian line temp else print1el jstL0 choice temp
+          temp <- generalProcMs syllableDurationsDs (if any (== 'a') choice then syllableDs else sDs) coeffs coeffsWX perms subs (intervalNmbrs, arg0, numberI, choice) syllables syllablesVs 
+          if recursiveMode then interactivePrintResultRecursive syllableDurationsDs (if any (== 'a') choice then syllableDs else sDs) pairwisePermutations recursiveMode nativeUkrainian interactive jstL0 args0 coeffs coeffsWX (convFSL bs . line2) temp args lstW2 syllables syllablesVs verbose
+          else if interactive then interactivePrintResult nativeUkrainian (convFSL bs . line2) temp syllables syllablesVs 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.
+     correct <- printWarning nativeUkrainian bs
+     if correct == "n" then putStrLn (messageInfo 1 nativeUkrainian) >> return (Str [],[]) -- 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 . (if pairwisePermutations == P 2 then genPairwisePermutationsLN else if pairwisePermutations == P 0 then genPermutationsL else genElementaryPermutationsLN1) $ l in do
-          temp <- generalProcMs syllableDurationsDs coeffs coeffsWX perms subs (intervalNmbrs, arg0, numberI, choice)
-          if recursiveMode then interactivePrintResultRecursive syllableDurationsDs pairwisePermutations recursiveMode nativeUkrainian interactive jstL0 args0 coeffs coeffsWX line temp args lstW2
-          else if interactive then interactivePrintResult nativeUkrainian line temp else print1el jstL0 choice temp
+          temp <- generalProcMs syllableDurationsDs (if any (== 'a') choice then syllableDs else sDs) coeffs coeffsWX perms subs (intervalNmbrs, arg0, numberI, choice) syllables syllablesVs 
+          if recursiveMode then interactivePrintResultRecursive syllableDurationsDs (if any (== 'a') choice then syllableDs else sDs) pairwisePermutations recursiveMode nativeUkrainian interactive jstL0 args0 coeffs coeffsWX (convFSL bs . line2) temp args lstW2 syllables syllablesVs verbose
+          else if interactive then interactivePrintResult nativeUkrainian (convFSL bs . line2) temp syllables syllablesVs else print1el jstL0 choice temp
+--------------------------------------------------------
   else do
    let !choices = map fst argMss
        !numericArgss = map snd argMss
@@ -219,26 +235,28 @@
          (\zs -> if null zs then [numberI] else L.nub zs) . L.sort . filter (<= numberI) .
            map (\t -> fromMaybe numberI $ (readMaybe t::Maybe Int)) . drop 2 $ us) $ numericArgss
        !argsZipped = L.zip4 intervalNmbrss arg0s numberIs choices
-       !xs = concat . take 1 . prepareTuneTextMN (if pairwisePermutations /= P 0 then 10 else 7) 1 . unwords $ args
-       !l = length . words $ xs
+       !bs = concat . take 1 . prepareTuneTextMN (if pairwisePermutations /= P 0 then 10 else 7) 1 . unwords $ args
+       !xs = Str bs
+       !l = length . words $ bs
        !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 tup1 tup2 tup3 tup4 tup5 tup6 tup7 tup8 tup9 tup10 tup11 tup12 tup13 tup14 tup15 tup16 tup17 syllableDurationsDs id coeffs (concat . take 1 $ choices)
-                                 !wwss = (:[]) . toResultR frep20 $ xs in
+   (syllDs,syllableDs,readys) <- do if syllables then weightsString3NIO syllablesVs (any id (map (any (== 'a')) choices)) bs else return ([],[],FSL [])
+   if compare l 2 == LT then let !frep20 = chooseMax tup1 tup2 tup3 tup4 tup5 tup6 tup7 tup8 tup9 tup10 tup11 tup12 tup13 tup14 tup15 tup16 tup17 (if any (== 'a') . concat . take 1 $ choices then syllableDs else syllableDurationsDs) id coeffs (concat . take 1 $ choices) bs
+                                 !wwss = (:[]) . toResultR2 frep20 $ xs in
      case recursiveMode of
-       True -> interactivePrintResultRecursive syllableDurationsDs pairwisePermutations recursiveMode nativeUkrainian interactive jstL0 args0 coeffs coeffsWX line wwss args lstW2
-       _ -> if interactive then interactivePrintResult nativeUkrainian line wwss else print1el jstL0 (concat . take 1 $ choices) wwss
+       True -> interactivePrintResultRecursive syllableDurationsDs (if syllables then syllableDs else sDs) pairwisePermutations recursiveMode nativeUkrainian interactive jstL0 args0 coeffs coeffsWX (convFSL bs . line2) wwss args lstW2 syllables syllablesVs verbose
+       _ -> if interactive then interactivePrintResult nativeUkrainian (convFSL bs . line2) wwss syllables syllablesVs else print1el jstL0 (concat . take 1 $ choices) wwss
    else do
-    let !subs = subG " 01-" xs
+    let !subs = subG " " bs
     if null argCs then let !perms
                              | pairwisePermutations == P 2 = genPairwisePermutationsLN l
                              | pairwisePermutations == P 1 = genElementaryPermutationsLN1 l
                              | otherwise = genPermutationsL l in
-       generalProcMMs syllableDurationsDs pairwisePermutations recursiveMode nativeUkrainian interactive jstL0 args0 coeffs coeffsWX argsZipped perms subs args lstW2
+       generalProcMMs syllableDurationsDs syllableDs pairwisePermutations recursiveMode nativeUkrainian interactive jstL0 args0 coeffs coeffsWX argsZipped perms subs args lstW2 syllables syllablesVs verbose
     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 . (if pairwisePermutations == P 2 then genPairwisePermutationsLN else if pairwisePermutations == P 0 then genPermutationsL else genElementaryPermutationsLN1) $ l in generalProcMMs syllableDurationsDs pairwisePermutations recursiveMode nativeUkrainian interactive jstL0 args0 coeffs coeffsWX argsZipped perms subs args lstW2
+     correct <- printWarning nativeUkrainian bs
+     if correct == "n" then putStrLn (messageInfo 1 nativeUkrainian) >> return (Str [],[]) -- 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 . (if pairwisePermutations == P 2 then genPairwisePermutationsLN else if pairwisePermutations == P 0 then genPermutationsL else genElementaryPermutationsLN1) $ l in generalProcMMs syllableDurationsDs syllableDs pairwisePermutations recursiveMode nativeUkrainian interactive jstL0 args0 coeffs coeffsWX argsZipped perms subs args lstW2 syllables syllablesVs verbose
 
 {-|
 -- @ since 0.4.0.0
@@ -273,9 +291,11 @@
  :: Bool
  -> (a -> String)
  -> [a]
- -> IO String
-interactivePrintResult nativeUkrainian f xss
-  | null xss = (putStrLn . messageInfo 5 $ nativeUkrainian) >> return ""
+ -> Bool -- ^ Whether to use volatile string weights
+ -> Int -- ^ Number of sets of volatile string weights for every processed line. Is used when the previous one is 'True'
+ -> IO (ReadyForConstructionUkr, String)
+interactivePrintResult nativeUkrainian f xss syllables syllablesVs
+  | null xss = (putStrLn . messageInfo 5 $ nativeUkrainian) >> return (Str [],[])
   | otherwise = do
      let !datas = map (\(idx,str) -> show idx `mappend` ('\t' : str)) . trans232 . map f $ xss
      mapM_ putStrLn datas
@@ -284,10 +304,11 @@
      number <- getLine
      let !lineRes = concat . filter ((number `mappend` "\t")`L.isPrefixOf`) $ datas
          !ts = drop 1 . dropWhile (/= '\t') $ lineRes
-     putStrLn ts >> return ts
+     putStrLn ts >> return (Str ts,ts)
 
 interactivePrintResultRecursive
- :: [[[[Sound8]]] -> [[Double]]] -- ^ Whether to use the own provided durations.
+ :: [[[[Sound8]]] -> [[Double]]] -- ^ Whether to use the own provided durations
+ -> [[[[Sound8]]] -> [[Double]]] -- ^ Whether to use the own volatile syllable durations.
  -> PermutationsType -- ^ Whether to use just one of the express permutations, or the full universal set.
  -> Bool
  -> Bool
@@ -300,9 +321,12 @@
  -> [a]
  -> [String]
  -> Bool
- -> IO String
-interactivePrintResultRecursive syllableDurationsDs pairwisePermutations recursiveMode nativeUkrainian interactive jstL0 args0 coeffs coeffsWX f xss args lstW2
-  | null xss = (putStrLn . messageInfo 5 $ nativeUkrainian) >> return ""
+ -> Bool -- ^ Whether to use volatile string weights
+ -> Int -- ^ Number of sets of volatile string weights for every processed line. Is used when the previous one is 'True'
+ -> Int
+ -> IO (ReadyForConstructionUkr, String)
+interactivePrintResultRecursive syllableDurationsDs sDs pairwisePermutations recursiveMode nativeUkrainian interactive jstL0 args0 coeffs coeffsWX f xss args lstW2 syllables syllablesVs verbose
+  | null xss = (putStrLn . messageInfo 5 $ nativeUkrainian) >> return (Str [],[])
   | otherwise = do
      let !datas = map (\(idx,str) -> show idx `mappend` ('\t' : str)) . trans232 . map f $ xss
      mapM_ putStrLn datas
@@ -313,7 +337,7 @@
          !ts = drop 1 . dropWhile (/= '\t') $ lineRes
      putStrLn . messageInfo 6 $ nativeUkrainian
      stringInterpreted <- getLine
-     if null stringInterpreted then putStrLn ts >> return ts
+     if null stringInterpreted then putStrLn ts >> return (Str ts,ts)
      else do
        let !firstArgs = takeWhile (not . all isLetter) args
        strIntrpr <- convStringInterpreterIO stringInterpreted ts
@@ -323,7 +347,7 @@
            mStr <- getLine
            let m = fromMaybe 10 (readMaybe mStr::Maybe Int) in return . take m . words $ strIntrpr
          else return . take 7 . words $ strIntrpr
-       generalProc2 syllableDurationsDs pairwisePermutations recursiveMode nativeUkrainian interactive jstL0 args0 coeffs coeffsWX (firstArgs `mappend` wordsNN) lstW2
+       generalProc2 syllableDurationsDs sDs pairwisePermutations recursiveMode nativeUkrainian interactive jstL0 args0 coeffs coeffsWX (firstArgs `mappend` wordsNN) lstW2 syllables syllablesVs verbose
 
 printWarning :: Bool -> String -> IO String
 printWarning nativeUkrainian xs = do
@@ -333,33 +357,42 @@
 
 generalProcMs
  :: [[[[Sound8]]] -> [[Double]]] -- ^ Whether to use the own provided durations.
+ -> [[[[Sound8]]] -> [[Double]]] -- ^ Whether to use the own volatile syllables durations.
  -> Coeffs2
  -> Coeffs2
  -> [Array Int Int]
  -> [String]
  -> ([Int],String,Int,String)
- -> IO [Result [] Char Double Double]
-generalProcMs syllableDurationsDs 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" || (take 1 choice == "H" && (drop 1 (take 2 choice) `elem` ["x","w"])) then chooseMax tup1 tup2 tup3 tup4 tup5 tup6 tup7 tup8 tup9 tup10 tup11 tup12 tup13 tup14 tup15 tup16 tup17 syllableDurationsDs id coeffsWX choice else chooseMax tup1 tup2 tup3 tup4 tup5 tup6 tup7 tup8 tup9 tup10 tup11 tup12 tup13 tup14 tup15 tup16 tup17 syllableDurationsDs id coeffs choice
-   in return . fst . (if any (== 'G') choice then partitioningR arg0 else maximumGroupsClassificationR (fromMaybe 1 (readMaybe arg0::Maybe Int))) . map (toResultR frep2) .
+ -> Bool -- ^ Whether to use volatile string weights
+ -> Int -- ^ Number of sets of volatile string weights for every processed line. Is used when the previous one is 'True'
+ -> IO [Result2 ReadyForConstructionUkr Double Double]
+generalProcMs syllableDurationsDs sDs coeffs coeffsWX perms subs (intervalNmbrs, arg0, numberI, choice) syllables syllablesVs = do
+  let bs = unwords subs
+  if compare numberI 2 == LT then let !frep2 = if any (\t -> t == 'x' || t == 'w') choice then chooseMax tup1 tup2 tup3 tup4 tup5 tup6 tup7 tup8 tup9 tup10 tup11 tup12 tup13 tup14 tup15 tup16 tup17 (if any (== 'a') choice then sDs else syllableDurationsDs) id coeffsWX choice bs else chooseMax tup1 tup2 tup3 tup4 tup5 tup6 tup7 tup8 tup9 tup10 tup11 tup12 tup13 tup14 tup15 tup16 tup17 (if any (== 'a') choice then sDs else syllableDurationsDs) id coeffs choice bs
+   in return . fst . (if any (== 'G') choice then partitioningR2 arg0 else maximumGroupsClassificationR_2 (fromMaybe 1 (readMaybe arg0::Maybe Int))) . map (toResultR2 frep2) . map Str .
         uniquenessVariants2GNBL ' ' id id id perms $ subs
   else do
     let !variants1 = uniquenessVariants2GNBL ' ' id id id perms subs
-        !frep20
-          | take 1 choice == "x" || take 1 choice == "w" ||
-              (take 1 choice == "H" && (drop 1 (take 2 choice) `elem` ["x","w"])) = chooseMax tup1 tup2 tup3 tup4 tup5 tup6 tup7 tup8 tup9 tup10 tup11 tup12 tup13 tup14 tup15 tup16 tup17 syllableDurationsDs id coeffsWX choice
-          | otherwise = chooseMax tup1 tup2 tup3 tup4 tup5 tup6 tup7 tup8 tup9 tup10 tup11 tup12 tup13 tup14 tup15 tup16 tup17 syllableDurationsDs id coeffs choice
-        (!minE,!maxE) = minMax11C . map (toPropertiesF' frep20) $ variants1
-        !frep2
-          | take 1 choice == "x" || take 1 choice == "w" ||
-              (take 1 choice == "H" && (drop 1 (take 2 choice) `elem` ["x","w"])) = chooseMax tup1 tup2 tup3 tup4 tup5 tup6 tup7 tup8 tup9 tup10 tup11 tup12 tup13 tup14 tup15 tup16 tup17 syllableDurationsDs (unsafeSwapVecIWithMaxI minE maxE numberI intervalNmbrs) coeffsWX choice
-          | otherwise = chooseMax tup1 tup2 tup3 tup4 tup5 tup6 tup7 tup8 tup9 tup10 tup11 tup12 tup13 tup14 tup15 tup16 tup17 syllableDurationsDs (unsafeSwapVecIWithMaxI minE maxE numberI intervalNmbrs) coeffs choice
-    return . fst . (if any (== 'G') choice then partitioningR arg0 else maximumGroupsClassificationR (fromMaybe 1 (readMaybe arg0::Maybe Int))) . map (toResultR frep2) $ variants1
+        !frep20 = chooseMax tup1 tup2 tup3 tup4 tup5 tup6 tup7 tup8 tup9 tup10 tup11 tup12 tup13 tup14 tup15 tup16 tup17 (if any (== 'a') choice then sDs else syllableDurationsDs) id (if any (\t -> t == 'x' || t == 'w') choice then coeffsWX else coeffs) choice bs
+        (!minE,!maxE) = minMax11C . map (toPropertiesF'2 frep20) $ map Str variants1
+        !frep2 = chooseMax tup1 tup2 tup3 tup4 tup5 tup6 tup7 tup8 tup9 tup10 tup11 tup12 tup13 tup14 tup15 tup16 tup17 (if any (== 'a') choice then sDs else syllableDurationsDs) (unsafeSwapVecIWithMaxI minE maxE numberI intervalNmbrs) (if any (\t -> t == 'x' || t == 'w') choice then coeffsWX else coeffs) choice bs
+    return . fst . (if any (== 'G') choice then partitioningR2 arg0 else maximumGroupsClassificationR_2 (fromMaybe 1 (readMaybe arg0::Maybe Int))) . map (toResultR2 frep2) $ map Str variants1
 
+show2 verbose jjs@(R2  x y z:_) = show1 bs   
+      where bs = sortBy (\(R2 xs d1 k1) (R2 ys d2 k2) -> case verbose of 
+              2 -> compare d2 d1
+              1 -> compare xs ys
+              3 -> compare k2 k1
+              _ -> EQ) jjs 
+            show1 qqs@(R2 x y z:ks) =  showR x `mappend` "->" `mappend` show y `mappend` "->" `mappend` show z `mappend` "\n" `mappend` show1 ks
+            show1 _ = ""
+
+print2 verbose = putStrLn . show2 verbose
 -- |
 -- @ since 0.3.0.0 The result is not 'IO' (), but 'IO' 'String'. The type also changed generally.
 generalProcMMs
  :: [[[[Sound8]]] -> [[Double]]] -- ^ Whether to use the own provided durations.
+ -> [[[[Sound8]]] -> [[Double]]] -- ^ Whether to use the own volatile syllables durations.
  -> PermutationsType  -- ^ Whether to use just pairwise permutations, or the full universal set.
  -> Bool
  -> Bool
@@ -373,26 +406,27 @@
  -> [String]
  -> [String]
  -> Bool
- -> IO String
-generalProcMMs syllableDurationsDs pairwisePermutations recursiveMode nativeUkrainian interactiveMM jstL0 args0 coeffs coeffsWX rs perms subs args lstW2 =
+ -> Bool -- ^ Whether to use volatile string weights
+ -> Int -- ^ Number of sets of volatile string weights for every processed line. Is used when the previous one is 'True'
+ -> Int
+ -> IO (ReadyForConstructionUkr, String)
+generalProcMMs syllableDurationsDs sDs pairwisePermutations recursiveMode nativeUkrainian interactiveMM jstL0 args0 coeffs coeffsWX rs perms subs args lstW2 syllables syllablesVs verbose =
  case length rs of
-  0 -> putStrLn (messageInfo 4 nativeUkrainian) >> return ""
+  0 -> putStrLn (messageInfo 4 nativeUkrainian) >> return (Str [],[])
   1 -> putStrLn (messageInfo 5 nativeUkrainian) >> do
-        temp <- generalProcMs syllableDurationsDs coeffs coeffsWX perms subs (head rs)
-        finalProc syllableDurationsDs pairwisePermutations recursiveMode nativeUkrainian interactiveMM jstL0 args0 coeffs coeffsWX line temp args lstW2
+        temp <- generalProcMs syllableDurationsDs sDs coeffs coeffsWX perms subs (head rs) syllables syllablesVs
+        if verbose `elem` [1..3] then print2 verbose temp >> putStrLn "" else putStr ""
+        finalProc syllableDurationsDs sDs pairwisePermutations recursiveMode nativeUkrainian interactiveMM jstL0 args0 coeffs coeffsWX (convFSL (unwords args) . line2) temp args lstW2 syllables syllablesVs verbose
   _ -> do
-         genVariants <- mapM (generalProcMs syllableDurationsDs coeffs coeffsWX perms subs) rs
-         finalProc syllableDurationsDs pairwisePermutations 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)
-foldlI ((!xs):_) = xs
-foldlI _ = []
+         genVariants <- mapM (\k -> generalProcMs syllableDurationsDs sDs coeffs coeffsWX perms subs k syllables syllablesVs) rs
+         if verbose `elem` [1..3] then mapM_ (\t -> print2 verbose t >> putStrLn "") genVariants else putStr ""
+         finalProc syllableDurationsDs sDs pairwisePermutations recursiveMode nativeUkrainian interactiveMM jstL0 args0 coeffs coeffsWX (convFSL (unwords args)) (foldlI (unwords args) . map (map line2) $ genVariants) args lstW2 syllables syllablesVs verbose
 
 -- |
 -- @ since 0.3.0.0 The result is not 'IO' (), but 'IO' 'String'. The type also changed generally.
 finalProc
  :: [[[[Sound8]]] -> [[Double]]] -- ^ Whether to use the own provided durations.
+ -> [[[[Sound8]]] -> [[Double]]] -- ^ Whether to use the own volatile syllables durations.
  -> PermutationsType -- ^ Whether to use just one of the express permutations, or the full universal set.
  -> Bool
  -> Bool
@@ -405,11 +439,14 @@
  -> [a]
  -> [String]
  -> Bool
- -> IO String
-finalProc syllableDurationsDs pairwisePermutations recursiveMode nativeUkrainian interactive jstL0 args0 coeffs coeffsWX f xss args lstW2
- | recursiveMode = interactivePrintResultRecursive syllableDurationsDs pairwisePermutations recursiveMode nativeUkrainian interactive jstL0 args0 coeffs coeffsWX f xss args lstW2
- | interactive = interactivePrintResult nativeUkrainian f xss
- | otherwise = putStrLn ts >> return ts
+ -> Bool -- ^ Whether to use volatile string weights
+ -> Int -- ^ Number of sets of volatile string weights for every processed line. Is used when the previous one is 'True'
+ -> Int
+ -> IO (ReadyForConstructionUkr, String)
+finalProc syllableDurationsDs sDs pairwisePermutations recursiveMode nativeUkrainian interactive jstL0 args0 coeffs coeffsWX f xss args lstW2 syllables syllablesVs verbose
+ | recursiveMode = interactivePrintResultRecursive syllableDurationsDs sDs pairwisePermutations recursiveMode nativeUkrainian interactive jstL0 args0 coeffs coeffsWX f xss args lstW2 syllables syllablesVs verbose
+ | interactive = interactivePrintResult nativeUkrainian f xss syllables syllablesVs
+ | otherwise = putStrLn ts >> return (Str ts,ts)
   where ts = concatMap (\t -> f t `mappend` newLineEnding) xss
 
 -- |
@@ -417,11 +454,12 @@
 print1el
  :: Bool
  -> String
- -> [Result [] Char Double Double]
- -> IO String
+ -> [Result2 ReadyForConstructionUkr Double Double]
+ -> IO (ReadyForConstructionUkr, String)
 print1el jstlines choice y
- | jstlines == True = putStrLn us >> return us
- | otherwise = putStrLn zs >> return zs
+ | jstlines == True = putStrLn us >> return (Str us,us)
+ | otherwise = putStrLn zs >> return (Str zs,zs)
        where !ch = precChoice choice
-             !us = concatMap (\ys -> line ys `mappend` newLineEnding) y
-             !zs = concatMap (\ys -> line ys `mappend` newLineEnding `mappend` showFFloat ch (propertiesF ys) (newLineEnding `mappend` showFFloat ch (transPropertiesF ys) newLineEnding)) y
+             !us = concatMap (\ys -> showR (line2 ys) `mappend` newLineEnding) y
+
+             !zs = concatMap (\ys -> showR (line2 ys) `mappend` newLineEnding `mappend` showFFloat ch (propertiesF2 ys) (newLineEnding `mappend` showFFloat ch (transPropertiesF2 ys) newLineEnding)) y
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
@@ -13,7 +13,6 @@
 
 import CaseBi.Arr
 import Phonetic.Languages.Basis
---import Phonetic.Languages.Array.Ukrainian.PropertiesSyllablesG2Common
 import Phonetic.Languages.Array.Ukrainian.Common
 import Phonetic.Languages.Array.Ukrainian.PropertiesFuncRepG2Diverse
 import Phonetic.Languages.Array.Ukrainian.PropertiesFuncRepG2Rhythmicity
@@ -25,6 +24,7 @@
 import GHC.Arr (Array, listArray)
 import GHC.Int (Int8)
 import Languages.Ukrainian.Data
+import Phonetic.Languages.Emphasis
 
 -- | Allows to choose the variant of the computations in case of usual processment.
 -- Since the 0.13.0.0 version there is a possibility to provide the list of durations specifications functions as the first
@@ -51,10 +51,11 @@
   -> (Double -> c)
   -> Coeffs2
   -> String
-  -> FuncRep2 String Double c
-chooseMax tup1 tup2 tup3 tup4 tup5 tup6 tup7 tup8 tup9 tup10 tup11 tup12 tup13 tup14 tup15 tup16 tup17 syllableDurationsDs g coeffs choice
- | any (== 'G') choice = chooseMax tup1 tup2 tup3 tup4 tup5 tup6 tup7 tup8 tup9 tup10 tup11 tup12 tup13 tup14 tup15 tup16 tup17 syllableDurationsDs g coeffs (filter (/= 'G') choice)
- | take 1 choice == "H" = procRhythmicity23FHTup tup1 tup2 tup3 tup4 tup5 tup6 tup7 tup8 tup9 tup10 tup11 tup12 tup13 tup14 tup15 tup16 tup17 1.3 g syllableDurationsDs choice coeffs
+  -> String -- ^ The starting 'String' which creates the order for the 'FSL' representation.
+  -> FuncRep2 ReadyForConstructionUkr Double c
+chooseMax tup1 tup2 tup3 tup4 tup5 tup6 tup7 tup8 tup9 tup10 tup11 tup12 tup13 tup14 tup15 tup16 tup17 syllableDurationsDs g coeffs choice bbs
+ | any (== 'G') choice = chooseMax tup1 tup2 tup3 tup4 tup5 tup6 tup7 tup8 tup9 tup10 tup11 tup12 tup13 tup14 tup15 tup16 tup17 syllableDurationsDs g coeffs (filter (/= 'G') choice) bbs
+ | take 1 choice == "H" || any (=='a') choice = procRhythmicity23FHTup tup1 tup2 tup3 tup4 tup5 tup6 tup7 tup8 tup9 tup10 tup11 tup12 tup13 tup14 tup15 tup16 tup17 1.3 g syllableDurationsDs choice coeffs bbs
  | take 1 choice `elem` ["c","M","N"] || (take 1 choice >= "A" && take 1 choice <= "F") = procRhythmicity23FTup tup1 tup2 tup3 tup4 tup5 tup6 tup7 tup8 tup9 tup10 tup11 tup12 tup13 tup14 tup15 tup16 tup17 1.3 g choice coeffs
  | getBFst' (False, listArray (0,1187) . 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",
@@ -167,3 +168,5 @@
 tup7 = listArray (0,18) [(8, дзT tup9 tup10),(10, жT),(17, дT),(21, гT),(25, зT tup9 tup10),(38, цT tup8 tup9 tup10),
               (39, чT),(41, шT),(43, фT), (45, кT),(47, пT),(49, сT tup8 tup9 tup10),(50, тT tup8 tup11 tup10),
                 (52, хT),(54, сьT),(62, нтT),(63, стT),(64, тьT),(66, цьT)]
+
+
diff --git a/Phonetic/Languages/Simplified/Array/Ukrainian/ReadProperties.hs b/Phonetic/Languages/Simplified/Array/Ukrainian/ReadProperties.hs
--- a/Phonetic/Languages/Simplified/Array/Ukrainian/ReadProperties.hs
+++ b/Phonetic/Languages/Simplified/Array/Ukrainian/ReadProperties.hs
@@ -19,11 +19,11 @@
 import Melodics.Ukrainian.ArrInt8
 
 
-{-| [(-1,\"-\"),(1,\"\1072\"),(2,\"\1077\"),(3,\"\1086\"),(4,\"\1091\"),(5,\"\1080\"),(6,\"\1110\"),
+{-| [(1,\"\1072\"),(2,\"\1077\"),(3,\"\1086\"),(4,\"\1091\"),(5,\"\1080\"),(6,\"\1110\"),
 (7,\"\1100\"),(8,\"\1076\1079\"),(10,\"\1078\"),(15,\"\1073\"),(17,\"\1076\"),(19,\"\1169\"),(21,\"\1075\"),
 (23,\"\1076\1078\"),(25,\"\1079\"),(27,\"\1081\"),(28,\"\1083\"),(30,\"\1084\"),(32,\"\1085\"),(34,\"\1088\"),
 (36,\"\1074\"),(38,\"\1094\"),(39,\"\1095\"),(41,\"\1096\"),(43,\"\1092\"),(45,\"\1082\"),(47,\"\1087\"),
-(49,\"\1089\"),(50,\"\1090\"),(52,\"\1093\"),(54,\"\1089\1100\"),(66,\"\1094\1100\")]
+(49,\"\1089\"),(50,\"\1090\"),(52,\"\1093\"),(54,\"\1089\1100\"),(66,\"\1094\1100\"),(101,\"-\")]
 @
 UZ \'A\' D       дз (plain)                 8
 UZ \'A\' K       дз (palatalized)           9
@@ -94,8 +94,8 @@
 @
 -}
 sound8s :: FlowSound
-sound8s = [-1,1,2,3,4,5,6,7,8,9,10,11,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,
-   43,44,45,46,47,48,49,50,51,52,53,54,66]
+sound8s = [1,2,3,4,5,6,7,8,9,10,11,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,
+   43,44,45,46,47,48,49,50,51,52,53,54,66,101]
 
 
 
diff --git a/README.md b/README.md
--- a/README.md
+++ b/README.md
@@ -6,22 +6,27 @@
 The short (possibly) instruction how to use the programs of the package
 phonetic-languages-simplified-examples-array in Ukrainian is here:
 
-https://oleksandrzhabenko.github.io/uk/rhythmicity/InstructionUkr.19.pdf
+https://oleksandrzhabenko.github.io/uk/rhythmicity/InstructionUkr.20.pdf
 
 or here:
 
-(try
-https://web.archive.org/web/20220531150915/https://oleksandrzhabenko.github.io/uk/rhythmicity/InstructionUkr.19.pdf)
+(try 
+https://web.archive.org/web/20220809192249/https://oleksandrzhabenko.github.io/uk/rhythmicity/InstructionUkr.20.pdf).
 
 The instruction in English is here:
 
-https://oleksandrzhabenko.github.io/uk/rhythmicity/InstructionEng.19.pdf
+https://oleksandrzhabenko.github.io/uk/rhythmicity/InstructionEng.20.pdf
 
 or here:
 
-(try
-https://web.archive.org/web/20220531151128/https://oleksandrzhabenko.github.io/uk/rhythmicity/InstructionEng.19.pdf)
+(try 
+https://web.archive.org/web/20220809192412/https://oleksandrzhabenko.github.io/uk/rhythmicity/InstructionEng.20.pdf).
 
+Since the version 0.20.0.0 added the second major mode of operation -- SaaW (syllable-as-a-whole),
+additionally to the previous functionality  of PhoPaaW (phonetic-phenomena-as-a-whole).
+
+For more information, see the instructions.
+
 Since the version 0.2.0.0 there exists also comparative mode for the
 rewritePoemG3 executable. It allows to create from two files with the
 text variants the new one. For more information in Ukrainian, please,
@@ -218,4 +223,4 @@
 rearrangements and string interpreter. Also improved the documentation
 and added examples of two sets of durations that is available as a
 ready-to-use file by the persistent link:
-https://web.archive.org/web/20220425124648/https://raw.githubusercontent.com/OleksandrZhabenko/phonetic-languages-data/main/56.csv
+https://web.archive.org/web/20220610171812/https://raw.githubusercontent.com/OleksandrZhabenko/phonetic-languages-data/main/0.20.0.0/56.csv
diff --git a/Simple/Main.hs b/Simple/Main.hs
--- a/Simple/Main.hs
+++ b/Simple/Main.hs
@@ -36,9 +36,13 @@
      lstW = listA ["+b","+bl"] argsA -- If one of the command line options is \"+b\" or \"+bl\" then the last word of the line will remain the last one.
      jstL0 = listA ["+l","+bl"] argsA -- If one of the command line options is \"+l\" or \"+bl\" then the program outputs just lines without metrices values.
      nativeUkrainian = oneA "+u" argsA -- 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.
+     verbose0 = concat . getB "+v" $ argsB -- ^ Whether to use more verbose output 
+     verbose = abs (fromMaybe 0 (readMaybe verbose0::Maybe Int) `rem` 4)
      toFileMode1 = concat . getB "+f" $ argsB -- Prints the last resulting line of the interactive mode processment (the last selected variant) to the file and also to the stdout.
      interactiveP = recursiveMode || oneA "+i" argsA || oneB "+f" argsB -- 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.
      textProcessmentFssFs = drop 1 . getC "+t" $ argsC2
+     syllables =  oneB "+s" argsB -- Whether to use syllable durations, up to 9 different sets.
+     syllablesVs = max 1 . fromMaybe 1 $ (readMaybe (concat . getB "+s" $ argsB)::Maybe Int) -- Number of sets of syllable durations to be used
      textProcessment0
        | null . concat . getB "+t" . fst . takeBsR [("+t",1)] $ argss = []
        | otherwise = "+t" `mappend` (concat . getB "+t" . fst . takeBsR [("+t",1)] $ argss)
@@ -47,9 +51,10 @@
  let args = snd . takeCs1R fstCharsMA [("+m",-1)] . snd . takeBsR [("+f",1)] . snd . takeCs1R fstCharsMA [("+a",-1)] $ arg2ss
      coeffs = readCF . concat . take 1 $ args -- The first command line argument.
  textProcessmentFss0 <- mapM (readFileIfAny) textProcessmentFssFs
+ print verbose
  let textProcessmentFss = filter (not . null) textProcessmentFss0
- if isPair coeffs then generalProc3G fileDu pairwisePermutations textProcessmentFss textProcessment0 textProcessment1 recursiveMode nativeUkrainian toFileMode1 interactiveP jstL0 args0 coeffs coeffsWX (drop 1 args) lstW
- else generalProc3G fileDu pairwisePermutations textProcessmentFss textProcessment0 textProcessment1 recursiveMode nativeUkrainian toFileMode1 interactiveP jstL0 args0 coeffs coeffsWX args lstW
+ if isPair coeffs then generalProc3G fileDu pairwisePermutations textProcessmentFss textProcessment0 textProcessment1 recursiveMode nativeUkrainian toFileMode1 interactiveP jstL0 args0 coeffs coeffsWX (drop 1 args) lstW syllables syllablesVs verbose
+ else generalProc3G fileDu pairwisePermutations textProcessmentFss textProcessment0 textProcessment1 recursiveMode nativeUkrainian toFileMode1 interactiveP jstL0 args0 coeffs coeffsWX args lstW syllables syllablesVs verbose
 
 aSpecs :: CLSpecifications
 aSpecs = zip ["+r","+b","+l","+bl","+i","+u"] . cycle $ [0]
@@ -70,7 +75,7 @@
 fstCharsT = ('+','^')
 
 bSpecs :: CLSpecifications
-bSpecs = zip ["+d","+f","+p"] . cycle $ [1]
+bSpecs = zip ["+d","+f","+p","+s","+v"] . cycle $ [1]
 
 bSpcs :: [String] -> Args
 bSpcs = fst . takeBsR bSpecs
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.19.0.0
+version:             0.20.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. To present the created text you can use e. g. html-presentation-text package: https://hackage.haskell.org/package/html-presentation-text .
 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, Phonetic.Languages.Simplified.Array.Ukrainian.ReadProperties
   -- other-modules:
   other-extensions:    BangPatterns
-  build-depends:       base >=4.8 && <5, ukrainian-phonetics-basic-array ==0.5.3.0, phonetic-languages-simplified-base ==0.5.0.0, phonetic-languages-basis ==0.1.0.0, phonetic-languages-simplified-properties-array ==0.14.0.0, phonetic-languages-simplified-properties-array-common ==0.1.0.0, phonetic-languages-ukrainian-array ==0.9.3.0, phonetic-languages-filters-array ==0.4.0.0, uniqueness-periods-vector-stats ==0.3.0.0, parallel >=3.2.0.6 && <4, phonetic-languages-plus ==0.6.0.0, subG == 0.5.3.0, phonetic-languages-rhythmicity ==0.9.2.0, phonetic-languages-permutations-array == 0.3.4.0, heaps >= 0.3.6.1 && <1,  phonetic-languages-constraints-array ==0.1.2.0, phonetic-languages-simplified-examples-common ==0.4.6.0, mmsyn2-array == 0.3.0.0, string-interpreter ==0.6.0.0, cli-arguments == 0.6.0.0, mmsyn2-array-ukrainian-data == 0.1.0.0, lists-flines == 0.1.2.0
+  build-depends:       base >=4.8 && <5, ukrainian-phonetics-basic-array ==0.6.0.0, phonetic-languages-simplified-base ==0.6.0.0, phonetic-languages-basis ==0.1.1.0, phonetic-languages-simplified-properties-array ==0.15.0.0, phonetic-languages-simplified-properties-array-common ==0.2.0.0, phonetic-languages-ukrainian-array ==0.9.3.0, phonetic-languages-filters-array ==0.4.0.0, uniqueness-periods-vector-stats ==0.3.0.0, parallel >=3.2.0.6 && <4, phonetic-languages-plus ==0.6.0.0, subG == 0.5.3.0, phonetic-languages-rhythmicity ==0.9.2.0, phonetic-languages-permutations-array == 0.3.4.0, heaps >= 0.3.6.1 && <1,  phonetic-languages-constraints-array ==0.1.2.0, phonetic-languages-simplified-examples-common ==0.5.0.0, mmsyn2-array == 0.3.0.0, string-interpreter ==0.6.0.0, cli-arguments == 0.6.0.0, mmsyn2-array-ukrainian-data == 0.1.0.0, lists-flines == 0.1.2.0
   -- 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, Phonetic.Languages.Simplified.Array.Ukrainian.ReadProperties
   other-extensions:    BangPatterns
-  build-depends:       base >=4.8 && <5, ukrainian-phonetics-basic-array ==0.5.3.0, phonetic-languages-simplified-base ==0.5.0.0, phonetic-languages-basis ==0.1.0.0, phonetic-languages-simplified-properties-array ==0.14.0.0, phonetic-languages-simplified-properties-array-common ==0.1.0.0, phonetic-languages-ukrainian-array ==0.9.3.0, phonetic-languages-filters-array ==0.4.0.0, uniqueness-periods-vector-stats ==0.3.0.0, parallel >=3.2.0.6 && <4, phonetic-languages-plus ==0.6.0.0, subG == 0.5.3.0, phonetic-languages-rhythmicity ==0.9.2.0, phonetic-languages-permutations-array == 0.3.4.0, heaps >= 0.3.6.1 && <1,  phonetic-languages-constraints-array ==0.1.2.0, phonetic-languages-simplified-examples-common ==0.4.6.0, mmsyn2-array == 0.3.0.0, string-interpreter ==0.6.0.0, cli-arguments == 0.6.0.0, mmsyn2-array-ukrainian-data == 0.1.0.0, lists-flines == 0.1.2.0
+  build-depends:       base >=4.8 && <5, ukrainian-phonetics-basic-array ==0.6.0.0, phonetic-languages-simplified-base ==0.6.0.0, phonetic-languages-basis ==0.1.1.0, phonetic-languages-simplified-properties-array ==0.15.0.0, phonetic-languages-simplified-properties-array-common ==0.2.0.0, phonetic-languages-ukrainian-array ==0.9.3.0, phonetic-languages-filters-array ==0.4.0.0, uniqueness-periods-vector-stats ==0.3.0.0, parallel >=3.2.0.6 && <4, phonetic-languages-plus ==0.6.0.0, subG == 0.5.3.0, phonetic-languages-rhythmicity ==0.9.2.0, phonetic-languages-permutations-array == 0.3.4.0, heaps >= 0.3.6.1 && <1,  phonetic-languages-constraints-array ==0.1.2.0, phonetic-languages-simplified-examples-common ==0.5.0.0, mmsyn2-array == 0.3.0.0, string-interpreter ==0.6.0.0, cli-arguments == 0.6.0.0, mmsyn2-array-ukrainian-data == 0.1.0.0, lists-flines == 0.1.2.0  
   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, Phonetic.Languages.Simplified.Array.Ukrainian.ReadProperties
   other-extensions:    BangPatterns
-  build-depends:       base >=4.8 && <5, ukrainian-phonetics-basic-array ==0.5.3.0, phonetic-languages-simplified-base ==0.5.0.0, phonetic-languages-basis ==0.1.0.0, phonetic-languages-simplified-properties-array ==0.14.0.0, phonetic-languages-simplified-properties-array-common ==0.1.0.0, phonetic-languages-ukrainian-array ==0.9.3.0, phonetic-languages-filters-array ==0.4.0.0, uniqueness-periods-vector-stats ==0.3.0.0, parallel >=3.2.0.6 && <4, phonetic-languages-plus ==0.6.0.0, subG == 0.5.3.0, phonetic-languages-rhythmicity ==0.9.2.0, phonetic-languages-permutations-array == 0.3.4.0, heaps >= 0.3.6.1 && <1,  phonetic-languages-constraints-array ==0.1.2.0, phonetic-languages-simplified-examples-common ==0.4.6.0, mmsyn2-array == 0.3.0.0, string-interpreter ==0.6.0.0, cli-arguments == 0.6.0.0, mmsyn2-array-ukrainian-data == 0.1.0.0, lists-flines == 0.1.2.0
+  build-depends:       base >=4.8 && <5, ukrainian-phonetics-basic-array ==0.6.0.0, phonetic-languages-simplified-base ==0.6.0.0, phonetic-languages-basis ==0.1.1.0, phonetic-languages-simplified-properties-array ==0.15.0.0, phonetic-languages-simplified-properties-array-common ==0.2.0.0, phonetic-languages-ukrainian-array ==0.9.3.0, phonetic-languages-filters-array ==0.4.0.0, uniqueness-periods-vector-stats ==0.3.0.0, parallel >=3.2.0.6 && <4, phonetic-languages-plus ==0.6.0.0, subG == 0.5.3.0, phonetic-languages-rhythmicity ==0.9.2.0, phonetic-languages-permutations-array == 0.3.4.0, heaps >= 0.3.6.1 && <1,  phonetic-languages-constraints-array ==0.1.2.0, phonetic-languages-simplified-examples-common ==0.5.0.0, mmsyn2-array == 0.3.0.0, string-interpreter ==0.6.0.0, cli-arguments == 0.6.0.0, mmsyn2-array-ukrainian-data == 0.1.0.0, lists-flines == 0.1.2.0
   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, Phonetic.Languages.Simplified.Array.Ukrainian.ReadProperties
   other-extensions:    BangPatterns
-  build-depends:       base >=4.8 && <5, ukrainian-phonetics-basic-array ==0.5.3.0, phonetic-languages-simplified-base ==0.5.0.0, phonetic-languages-basis ==0.1.0.0, phonetic-languages-simplified-properties-array ==0.14.0.0, phonetic-languages-simplified-properties-array-common ==0.1.0.0, phonetic-languages-ukrainian-array ==0.9.3.0, phonetic-languages-filters-array ==0.4.0.0, uniqueness-periods-vector-stats ==0.3.0.0, parallel >=3.2.0.6 && <4, phonetic-languages-plus ==0.6.0.0, subG == 0.5.3.0, phonetic-languages-rhythmicity ==0.9.2.0, phonetic-languages-permutations-array == 0.3.4.0, heaps >= 0.3.6.1 && <1,  phonetic-languages-constraints-array ==0.1.2.0, phonetic-languages-simplified-examples-common ==0.4.6.0, mmsyn2-array == 0.3.0.0, string-interpreter ==0.6.0.0, cli-arguments == 0.6.0.0, mmsyn2-array-ukrainian-data == 0.1.0.0, lists-flines == 0.1.2.0
+  build-depends:       base >=4.8 && <5, ukrainian-phonetics-basic-array ==0.6.0.0, phonetic-languages-simplified-base ==0.6.0.0, phonetic-languages-basis ==0.1.1.0, phonetic-languages-simplified-properties-array ==0.15.0.0, phonetic-languages-simplified-properties-array-common ==0.2.0.0, phonetic-languages-ukrainian-array ==0.9.3.0, phonetic-languages-filters-array ==0.4.0.0, uniqueness-periods-vector-stats ==0.3.0.0, parallel >=3.2.0.6 && <4, phonetic-languages-plus ==0.6.0.0, subG == 0.5.3.0, phonetic-languages-rhythmicity ==0.9.2.0, phonetic-languages-permutations-array == 0.3.4.0, heaps >= 0.3.6.1 && <1,  phonetic-languages-constraints-array ==0.1.2.0, phonetic-languages-simplified-examples-common ==0.5.0.0, mmsyn2-array == 0.3.0.0, string-interpreter ==0.6.0.0, cli-arguments == 0.6.0.0, mmsyn2-array-ukrainian-data == 0.1.0.0, lists-flines == 0.1.2.0
   ghc-options:         -threaded -rtsopts
   hs-source-dirs:      ., GetInfo
   default-language:    Haskell2010