diff --git a/CHANGELOG.md b/CHANGELOG.md
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -51,3 +51,7 @@
 * Sixth version. Added packages mmsyn2 and mmsyn5 as a dependencies explicitly (earlier they wele as implicit dependencies because they are dependencies for
 mmsyn6ukr). Added the module MMSyn7.Syllable and the instruments to work with syllables. Added ghc-options for mmsyn7s.cabal file. Added some performance
 improvements to the previous code. Some grammar issues fixed.
+
+## 0.6.1.0 -- 2020-02-28
+
+* Sixth version revised A. Fixed issue with the not being compiled because of the deprecated information in the mmsyn7s.cabal file.
diff --git a/MMSyn7/Syllable.hs b/MMSyn7/Syllable.hs
new file mode 100644
--- /dev/null
+++ b/MMSyn7/Syllable.hs
@@ -0,0 +1,197 @@
+-- |
+-- Module      :  MMSyn7.Syllable
+-- Copyright   :  (c) OleksandrZhabenko 2020
+-- License     :  MIT
+-- Stability   :  Experimental
+-- Maintainer  :  olexandr543@yahoo.com
+--
+-- A program and a library that show a sorted list of the Ukrainian sounds 
+-- representations that can be used by mmsyn7 series of programs. This module
+-- works with syllable segmentation.
+--
+
+{-# LANGUAGE DeriveDataTypeable #-}
+
+module MMSyn7.Syllable (
+  -- * Datatype for the Ukrainian sounds representations
+  UZP
+  -- * The resulting functions
+  , syllablesUkr
+  , takeWordS
+  , sylLengths
+  -- * Used internally
+  , createSyllables
+  , divideConsonants
+  , groupConsonants
+  , sndGroups
+  , takeWithV
+  , vecToUZPs
+  , vecWords
+  , uzpsToList
+  -- * Auxiliary predicate functions
+  , isNotVowel2
+  , isSonorous1
+  , isVoicedC1
+  , isVoicelessC1
+  , isVowel1
+  , isVwl
+  , notEqC
+) where
+
+import Data.Typeable
+import qualified Data.Vector as V
+import qualified Data.List as L (groupBy,span)
+import Melodics.Ukrainian (convertToProperUkrainian)
+import CaseBi (getBFst')
+import Data.List.InnToOut.Basic (mapI)
+
+-- Inspired by: https://github.com/OleksandrZhabenko/mm1/releases/tag/0.2.0.0
+
+-- CAUTION: Please, do not mix with the show7s functions, they are not interoperable.
+
+-- | Datatype 'UZP' is a simple sound classification type. Its peculiarity is that it is shown as a usual String (by design corresponding to the Ukrainian sound).
+data UZP = Vowel String | Sonorous String | SonorousP String | Voiced String | VoicedP String | Voiceless String | VoicelessP String | VoicelessP2 String
+  deriving ( Eq, Typeable )
+
+instance Ord UZP
+  where compare x y = compare (show x) (show y)
+
+instance Show UZP
+  where show (SonorousP xs) = xs ++ "ь"
+        show (VoicedP xs) = xs ++ "ь"
+        show (VoicelessP xs) = xs ++ "ь"
+        show (Vowel xs) = xs
+        show (VoicelessP2 xs) = xs
+        show (Sonorous xs) = xs
+        show (Voiced xs) = xs
+        show (Voiceless xs) = xs  
+
+-- | Function 'vecToUZPs' is used to convert a @Vector@ of @String@ representing Ukrainian sounds to a list of 'UZP'.
+vecToUZPs :: V.Vector String -> [UZP]
+vecToUZPs v
+  | V.null v = []
+  | getBFst' (False, (V.fromList . zip ["а","е","и","о","у","і"] $ (replicate 6 True))) . V.unsafeHead $ v = (Vowel (V.unsafeHead v)):vecToUZPs (V.unsafeTail v)
+  | V.unsafeHead v == "сь" || V.unsafeHead v == "ць" = (VoicelessP2 (V.unsafeHead v)):(vecToUZPs (V.unsafeTail v))
+  | ((V.null . V.unsafeTail $ v) || (V.unsafeIndex v 1 /= "ь")) && getBFst' (False, V.fromList . zip ["в","й","л","м","н","р"] $ (replicate 6 True)) (V.unsafeHead v) = (Sonorous (V.unsafeHead v)):(if V.null . V.unsafeTail $ v then [] else vecToUZPs (V.unsafeTail v))
+  | ((V.null . V.unsafeTail $ v) || (V.unsafeIndex v 1 /= "ь")) && getBFst' (False, V.fromList . zip ["б","г","д","дж","дз","ж","з","ґ"] $ (replicate 8 True)) (V.unsafeHead v) = (Voiced (V.unsafeHead v)):(if V.null . V.unsafeTail $ v then [] else vecToUZPs (V.unsafeTail v))
+  | ((V.null . V.unsafeTail $ v) || (V.unsafeIndex v 1 /= "ь")) = (Voiceless (V.unsafeHead v)):(if V.null . V.unsafeTail $ v then [] else vecToUZPs (V.unsafeTail v))
+  | getBFst' (False, V.fromList . zip ["в","л","м","н","р"] $ (replicate 5 True)) (V.unsafeHead v) = (SonorousP (V.unsafeHead v)):vecToUZPs (V.unsafeDrop 2 v)
+  | getBFst' (False, V.fromList . zip ["б","г","д","дж","дз","ж","з","ґ"] $ (replicate 8 True)) (V.unsafeHead v) = (VoicedP (V.unsafeHead v)):vecToUZPs (V.unsafeDrop 2 v)
+  | otherwise = (VoicelessP (V.unsafeHead v)):vecToUZPs (V.unsafeDrop 2 v)
+
+-- | Function 'sndGroups' converts a Ukrainian word being a list of 'UZP' to the list of phonetically similar (consonants with consonants and vowels separately) 
+-- sounds representations in 'UZP' format.
+sndGroups :: [UZP] -> [[UZP]]
+sndGroups ys@(_:_) = L.groupBy isNotVowel2 ys
+sndGroups _ = []
+
+-- | Function-predicate 'isVowel1' checks whether its argument is a vowel representation in the 'UZP' format.
+isVowel1 :: UZP -> Bool
+isVowel1 (Vowel _) = True
+isVowel1 _ = False
+
+-- | Function-predicate 'isVwl' checks whether its argument is a vowel representation in the 'Char' format.
+isVwl :: Char -> Bool
+isVwl = getBFst' (False, (V.fromList . zip "аеиоуі" $ (replicate 6 True)))
+
+-- | Function-predicate 'isSonorous1' checks whether its argument is a sonorous consonant representation in the 'UZP' format.
+isSonorous1 :: UZP -> Bool
+isSonorous1 (Sonorous _) = True
+isSonorous1 (SonorousP _) = True
+isSonorous1 _ = False
+
+-- | Function-predicate 'isVoicedC1' checks whether its argument is a voiced consonant representation in the 'UZP' format.
+isVoicedC1 ::  UZP -> Bool
+isVoicedC1 (Voiced _) = True
+isVoicedC1 (VoicedP _) = True
+isVoicedC1 _ = False
+
+-- | Function-predicate 'isVoiceless1' checks whether its argument is a voiceless consonant representation in the 'UZP' format.
+isVoicelessC1 ::  UZP -> Bool
+isVoicelessC1 (Voiceless _) = True
+isVoicelessC1 (VoicelessP _) = True
+isVoicelessC1 _ = False
+
+-- | Binary function-predicate 'isNotVowel2' checks whether its arguments are both consonant representations in the 'UZP' format.
+isNotVowel2 :: UZP -> UZP -> Bool
+isNotVowel2 x y | isVowel1 x || isVowel1 y = False
+                | otherwise = True
+
+-- | Binary function-predicate 'notEqC' checks whether its arguments are not the same consonant sound representations (not taking palatalization into account).
+notEqC :: UZP -> UZP -> Bool
+notEqC x y =
+  case x of
+    (Vowel _) -> True
+    _         ->
+      case y of
+        (Vowel _) -> True
+        _         -> compare x y /= EQ
+
+-- | Function 'vecWords' similarly to 'Prelude.words' divides a 'V.Vector' of 'String' into list of them, each element of which is a Ukrainian word (or its part 
+-- for dashed and hyphenated words).
+vecWords :: V.Vector String -> [V.Vector String]
+vecWords v | V.null v = []
+           | V.unsafeHead v == "-" || V.unsafeHead v == "0" || V.unsafeHead v == "1" = vecWords (V.unsafeTail v)
+           | otherwise = 
+  let (v1, v2) = V.break (\x -> x == "-" || x == "0" || x == "1") v
+      v3       = snd . V.span (\x -> x == "-" || x == "0" || x == "1") $ v2 in v1:vecWords v3
+
+-- | Function 'divideConsonants' is used to divide groups of Ukrainian consonants into two-elements lists that later are made belonging to different neighbour syllables
+-- if the group is between two vowels in a word. The group must be not empty, but this is not checked.
+-- The phonetical information for the proper performance is taken from the:
+-- https://msn.khnu.km.ua/pluginfile.php/302375/mod_resource/content/1/%D0%9B.3.%D0%86%D0%86.%20%D0%A1%D0%BA%D0%BB%D0%B0%D0%B4.%D0%9D%D0%B0%D0%B3%D0%BE%D0%BB%D0%BE%D1%81.pdf
+divideConsonants :: [UZP] -> [[UZP]]
+divideConsonants xs = case length xs of
+  1 -> [[],xs]
+  2 -> if ((isSonorous1 . head $ xs) && (head xs `notEqC` last xs)) || ((isVoicedC1 . head $ xs) && (isVoicelessC1 . head . tail $ xs)) then [[head xs], tail xs] else [[],xs]
+  3 -> if isSonorous1 . head $ xs then [[head xs], tail xs]
+       else if isSonorous1 . head . tail $ xs then [[head xs, head . tail $ xs], [last xs]]
+       else [[],xs]
+  _ -> if (isSonorous1 . head $ xs) || (isVoicedC1 . head $ xs) then [[head xs], tail xs] else [[],xs]
+
+-- | Function 'groupConsonants' is used to apply 'divideConsonants' to the needed groups of consonants.
+groupConsonants :: [[UZP]] -> [[UZP]]
+groupConsonants = mapI (not . isVowel1 . head) divideConsonants
+
+-- | Function 'uzpsToList' converts a Ukrainian word being a list of syllables in 'UZP' format to a list of 'String'.
+uzpsToList :: [[UZP]] -> [String]
+uzpsToList xss = map (concatMap show) xss
+
+-- | Function 'createSyllables' takes a prepared Ukrainian word and joins the parts (being a list of @UZP@) so that they constitute syllables.
+createSyllables :: [[UZP]] -> [String]
+createSyllables xss =
+  let (tss, vss) = L.span (any isVwl) . takeWithV $ xss in
+    if null tss
+      then [concat . takeWithV $ xss]
+      else concat [init tss, [last tss ++ concat vss]]
+
+-- | Function 'syllablesUkr' actually converts a 'String' to the list of words being segmented into the syllables. If the Ukrainian word being written down contains
+-- an apostrophe or a dash (hyphen) signs (or even both) then they are treated as separators for the distinguished words. This does not influence the syllable structure
+-- and so the poetic characteristics of the text.
+syllablesUkr :: String -> [[String]]
+syllablesUkr xs = map ( createSyllables . groupConsonants . sndGroups . vecToUZPs) . vecWords . convertToProperUkrainian $ xs
+
+-- | Function 'takeWithV' is used internally in the 'createSyllables'.
+takeWithV :: [[UZP]] -> [String]
+takeWithV ((x@(t:ts)):ys:xss)
+  | (isVowel1 t) && (null ys) = show t:takeWithV xss
+  | (isVowel1 t) && (isVowel1 . head $ ys) = show t:takeWithV (ys:xss)
+  | (isVowel1 t) = (show t ++ (show . head $ ys)):takeWithV xss
+  | otherwise = (concatMap show x ++ (head . takeWithV $ (ys:xss))):(tail . takeWithV $ (ys:xss))
+takeWithV (_:ys:xss) = takeWithV (ys:xss)
+takeWithV (x:xs) = map show x
+takeWithV _ = []
+
+-- | Function 'takeWordS' takes a number (which is its second argument) of the Ukrainian words and represents them as a list of list of 'String', each of which is a syllable.
+-- If the Ukrainian word being written down contains an apostrophe or a dash (hyphen) signs (or even both) then they are treated as separators for the distinguished words.
+-- This does not influence the syllable structure and so the poetic characteristics of the text.
+takeWordS :: String -> Int -> [[String]]
+takeWordS xs n = take n . syllablesUkr $ xs
+
+-- | Function 'sylLengths' shows number of Ukrainian letters (except 'ь') in the syllables in the text needed to represent a sounding of the text,
+-- which was previously converted with 'syllablesUkr' function. If the syllable does not contain either sounds "дж" / "дз" or prolonged sounds then this number
+-- is also a number of sounds in it. 
+-- If the Ukrainian word being written down contains an apostrophe or a dash (hyphen) signs (or even both) then they are treated as separators for the distinguished words.
+-- This does not influence the syllable structure and so the poetic characteristics of the text.
+sylLengths :: [[String]] -> [[Int]]
+sylLengths = fmap (fmap (length . filter (/= 'ь')))
diff --git a/MMSyn7s.hs b/MMSyn7s.hs
--- a/MMSyn7s.hs
+++ b/MMSyn7s.hs
@@ -107,7 +107,7 @@
                  ; putStrLn "which shows what sound representations are needed to be created if every sound is unique; "
                  ; putStrLn "      the other beginning is equivalent to the \"0\" behaviour."
                   }
-      "-v" -> putStrLn "mmsyn7s: version 0.6.0.0"
+      "-v" -> putStrLn "mmsyn7s: version 0.6.1.0"
       "-s" -> let ys = unwords . drop 1 $ texts in
                 do { putStrLn $ "Uniqueness periods:                                                      " ++ (show . uniquenessPeriods $ ys)
                    ; putStrLn $ "Possibly unique sounds representations density:                          " ++ (show . sndsDensity $ ys)
diff --git a/mmsyn7s.cabal b/mmsyn7s.cabal
--- a/mmsyn7s.cabal
+++ b/mmsyn7s.cabal
@@ -2,7 +2,7 @@
 -- documentation, see http://haskell.org/cabal/users-guide/
 
 name:                mmsyn7s
-version:             0.6.0.0
+version:             0.6.1.0
 synopsis:            Shows a sorted list of the Ukrainian sounds representations that can be used by mmsyn7 series of programs
 description:         A program and a library that show a sorted list of the Ukrainian sounds representations that can be used by mmsyn7 series of programs
 homepage:            https://hackage.haskell.org/package/mmsyn7s
@@ -17,7 +17,7 @@
 cabal-version:       >=1.10
 
 library
-  exposed-modules:     MMSyn7s, Main
+  exposed-modules:     MMSyn7s, Main, MMSyn7.Syllable
   -- other-modules:
   -- other-extensions:
   build-depends:       base >=4.7 && <4.14, vector >=0.11 && <0.14, mmsyn6ukr >=0.6.2 && <1, mmsyn2 >=0.1.7.0 && < 1, mmsyn5 >=0.4.2.2  && < 1