diff --git a/CHANGELOG.md b/CHANGELOG.md
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -72,3 +72,17 @@
 
 * Fifth version revised A. Updated the dependencies to use the new functionality.
 
+## 0.6.0.0 -- 2023-03-01
+
+* Sixth version. Switched to NoImplicitPrelude extension. Updated the dependencies boundaries
+to support the new functionality.
+
+## 0.6.1.0 -- 2023-03-02
+
+* Sixth version revised A. Fixed issue with the same name of the module from the phonetic-languages-simplified-properties-array-common package.
+
+## 0.6.2.0 -- 2023-03-15
+
+* Sixth version revised B. Updated the dependencies boundaries so that to support the 
+new code deduplication for different implementations of PhLADiPreLiO.
+
diff --git a/LICENSE b/LICENSE
--- a/LICENSE
+++ b/LICENSE
@@ -1,4 +1,4 @@
-Copyright (c) 2020-2022 OleksandrZhabenko
+Copyright (c) 2020-2023 Oleksandr Zhabenko
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the
diff --git a/Phladiprelio/Ukrainian/CommonE.hs b/Phladiprelio/Ukrainian/CommonE.hs
new file mode 100644
--- /dev/null
+++ b/Phladiprelio/Ukrainian/CommonE.hs
@@ -0,0 +1,63 @@
+{-# OPTIONS_GHC -threaded -rtsopts #-}
+{-# OPTIONS_HADDOCK show-extensions #-}
+{-# LANGUAGE BangPatterns, FlexibleContexts, NoImplicitPrelude #-}
+
+-- |
+-- Module      :  Phladiprelio.Ukrainian.CommonE
+-- Copyright   :  (c) Oleksandr Zhabenko 2020-2023
+-- License     :  MIT
+-- Stability   :  Experimental
+-- Maintainer  :  oleksandr.zhabenko@yahoo.com
+--
+-- Some functions to provide show and print functionality for PhLADiPreLiO for Ukrainian language.
+--
+
+module Phladiprelio.Ukrainian.CommonE (
+  fLinesN
+  , fLines
+  , fLinesNIO
+  , fLinesIO
+) where
+
+import GHC.Base hiding (foldr)
+import GHC.List (filter, break, dropWhile, init)
+import Phladiprelio.Ukrainian.PrepareText
+import Data.Char (isAlpha,isSpace)
+import Data.Monoid (mappend)
+import Data.Foldable (Foldable (..), any)
+import GHC.Num ((+),(-))
+import Text.Show (show)
+import System.IO (putStrLn)
+
+fLinesN :: Int -> Int -> String -> [String]
+fLinesN n !toOneLine ys = filter (any (\x -> isUkrainianL x && isAlpha x)) . prepareTextN n .
+  (\z -> if toOneLine == 1 then unls z else z) $ ys
+   -- the 'unls' is taken from the 'Data.List.words' and rewritten to be equal to 'unwords' . 'words'
+   where unls s  =  case dropWhile isSpace s of
+                      "" -> []
+                      s' -> w `mappend` (' ' : unls s'')
+                        where (w, s'') = break isSpace s'
+
+fLines :: Int -> String -> [String]
+fLines = fLinesN 7
+{-# INLINE fLines #-}
+
+fLinesNIO :: Int -> String -> IO ()
+fLinesNIO n ys = mapM putStrLn (map (\(i,x) -> show (i + 1) `mappend` "\t" `mappend` x) . helpG3 . indexedL "" .
+   filter (any (\x -> isUkrainianL x && isAlpha x)) . prepareTextN n $ ys) >> return ()
+
+fLinesIO :: String -> IO ()
+fLinesIO = fLinesNIO 7
+{-# INLINE fLinesIO #-}
+
+-- | Is taken mostly from the Phonetic.Languages.Ukrainian.Simplified.Lists.UniquenessPeriodsG module from the @phonetic-languages-simplified-common@ package.
+indexedL :: Foldable t => b -> t b -> [(Int, b)]
+indexedL y zs = foldr f v zs
+  where !v = [(length zs,y)]
+        f x ((j,z):ys) = (j-1,x):(j,z):ys
+{-# INLINE indexedL #-}
+
+helpG3 :: [a] -> [a]
+helpG3 xs
+ | null xs = []
+ | otherwise = init xs
diff --git a/Phladiprelio/Ukrainian/DeEnCoding.hs b/Phladiprelio/Ukrainian/DeEnCoding.hs
new file mode 100644
--- /dev/null
+++ b/Phladiprelio/Ukrainian/DeEnCoding.hs
@@ -0,0 +1,151 @@
+{-# OPTIONS_GHC -threaded -rtsopts #-}
+{-# OPTIONS_HADDOCK show-extensions #-}
+{-# LANGUAGE BangPatterns, NoImplicitPrelude #-}
+
+-- |
+-- Module      :  Phladiprelio.Ukrainian.DeEnCoding
+-- Copyright   :  (c) Oleksandr Zhabenko 2020-2023
+-- License     :  MIT
+-- Stability   :  Experimental
+-- Maintainer  :  oleksandr.zhabenko@yahoo.com
+--
+-- Functions to encode and decode 'String' -> \['Int8'\] used in the Simple/Main.hs code.
+-- Is taken from the @phonetic-languages-simplified-lists-examples@ package.
+
+module Phladiprelio.Ukrainian.DeEnCoding where
+
+import GHC.Base hiding (foldr)
+import GHC.Num ((+),(-),(*))
+import GHC.Real (quotRem)
+import GHC.Enum (fromEnum,toEnum)
+import Data.Tuple (fst,snd)
+import qualified Data.Heap as Heap
+import GHC.Int
+import System.IO
+import Data.Maybe (fromJust)
+import Numeric (showHex,readHex)
+import Phladiprelio.Ukrainian.Emphasis
+import Phladiprelio.Ukrainian.Melodics (FlowSound)
+import Phladiprelio.Ukrainian.Syllable
+import Data.Foldable (Foldable, foldr,null,foldl')
+import Data.List (sort,head,words,zip,length,unwords,init,partition,sortOn)
+
+--default (Int, Double)
+
+encodeToInt :: Ord a => [[a]] -> Int
+encodeToInt yss
+ | null ks = -1
+ | otherwise = fst . head $ ks
+  where ks = readHex (showHex (foldl' (\x y -> x * 16 + y) 0 . map (\(j,_) -> fromEnum j) . sortOn snd . trans2 $ yss) $ "")
+{-# INLINABLE encodeToInt #-}
+
+-- | Is taken mostly from the Phonetic.Languages.Ukrainian.Simplified.Lists.UniquenessPeriodsG module from the @phonetic-languages-simplified-common@ package.
+indexedL :: Foldable t => b -> t b -> [(Int8, b)]
+indexedL y zs = foldr f v zs
+  where !v = [(toEnum (length zs + 1),y)]
+        f x ((j,z):ys) = (j-1,x):(j,z):ys
+{-# INLINE indexedL #-}
+
+trans2 :: [[a]] -> [(Int8, [a])]
+trans2 = init . indexedL []
+{-# INLINE trans2 #-}
+
+trans232 :: [[a]] -> [(Int, [a])]
+trans232 zs = init . foldr f v $ zs
+  where !v = [(length zs + 1,[])]
+        f x ((j,z):ys) = (j-1,x):(j,z):ys
+{-# INLINE trans232 #-}
+
+int2l :: Int -> [Int8]
+int2l n
+ | n < 16 = [toEnum n]
+ | otherwise = int2l n1 `mappend` [l]
+     where (!n1,!l0) = quotRem n 16
+           !l = toEnum l0
+{-# INLINABLE int2l #-}
+
+-- | So for the strings consisting of no more than 10 words:
+-- > decodeToStr (int2l . encodeToInt . words $ xs) xs == unwords . words $ xs
+--
+decodeToStr :: [Int8] -> String -> String
+decodeToStr ys = unwords . map snd . sortOn fst . zip ys . sort . words
+{-# INLINE decodeToStr #-}
+
+-- | For the 'ReadyForConstructionUkr' that corresponds to the 'String' consisting of no more than 10 words.
+--
+decodeToReadyFCUkr :: [Int8] -> ReadyForConstructionUkr -> ReadyForConstructionUkr
+decodeToReadyFCUkr ys (Str ts) = Str . unwords . map snd . sortOn fst . zip ys . sort . words $ ts
+decodeToReadyFCUkr ys (FSL tsss) = FSL . map snd . sortOn fst . zip ys . sort $ tsss
+{-# INLINE decodeToReadyFCUkr #-}
+
+-- | Every 'String' consists of words with whitespace symbols in between.
+toHeap :: [String] -> Heap.Heap Int
+toHeap yss@(xs:xss)
+  | null xss = Heap.singleton . encodeToInt . words $ xs
+  | otherwise = Heap.fromList . map (encodeToInt . words) $ yss
+toHeap _ = Heap.empty
+{-# INLINE toHeap #-}
+
+-- | Every 'ReadyForConstructionUkr' corresponds to the 'String' that consists of words with whitespace symbols in between.
+-- The list must be consistent -- either 'FSL'-constructed or 'Str'-constructed.
+toHeapR :: [ReadyForConstructionUkr] -> Heap.Heap Int
+toHeapR yss@(xs@(Str ts):xss)
+  | null xss = Heap.singleton . encodeToInt . words $ ts
+  | otherwise = Heap.fromList . map (encodeToInt . words . fromJust . fromReadyFCUkrS) $ yss
+toHeapR yss@(xs@(FSL tsss):xss)
+  | null xss = Heap.singleton . encodeToInt $ tsss
+  | otherwise = Heap.fromList . map (encodeToInt . fromJust . fromReadyFCUkrF) $ yss  
+toHeapR _ = Heap.empty
+{-# INLINE toHeapR #-}
+
+fromHeap :: String -> Heap.Heap Int -> [String]
+fromHeap ys heap
+ | Heap.null heap = []
+ | otherwise = map (flip decodeToStr ys . int2l) . Heap.toUnsortedList $ heap
+{-# INLINE fromHeap #-}
+
+fromHeapReadyFCUkr :: ReadyForConstructionUkr -> Heap.Heap Int -> [ReadyForConstructionUkr]
+fromHeapReadyFCUkr ys heap
+ | Heap.null heap = []
+ | otherwise = map (flip decodeToReadyFCUkr ys . int2l) . Heap.toUnsortedList $ heap
+{-# INLINE fromHeapReadyFCUkr #-}
+
+intersectInterResults :: [String] -> [String] -> [String]
+intersectInterResults zss
+ | null zss = const []
+ | otherwise = fromHeap (head zss) . Heap.intersect (toHeap zss) . toHeap
+{-# INLINE intersectInterResults #-}
+
+intersectInterReadyFCUkr :: (String -> [[FlowSound]]) -> [ReadyForConstructionUkr] -> [ReadyForConstructionUkr] -> [ReadyForConstructionUkr]
+intersectInterReadyFCUkr convF zss tss
+ | null zss = []
+ | null tss = []
+ | (isStr . head $ tss) && (isStr . head $ zss) = fromHeapReadyFCUkr (head zss) . Heap.intersect (toHeapR zss) . toHeapR $ tss
+ | (isFSL . head $ tss) && (isFSL . head $ zss) = fromHeapReadyFCUkr (head zss) . Heap.intersect (toHeapR zss) . toHeapR $ tss
+ | isStr . head $ tss = fromHeapReadyFCUkr (head zss) . Heap.intersect (toHeapR zss) . toHeapR . map (FSL . convF . fromJust . fromReadyFCUkrS) $ tss
+ | otherwise = fromHeapReadyFCUkr (head tss) . Heap.intersect (toHeapR . map (FSL . convF . fromJust . fromReadyFCUkrS) $ zss) . toHeapR $ tss
+{-# INLINE intersectInterReadyFCUkr #-}
+
+intersectInterReadyFCUkr2 :: String -> [ReadyForConstructionUkr] -> [ReadyForConstructionUkr] -> [ReadyForConstructionUkr]
+intersectInterReadyFCUkr2 ts = intersectInterReadyFCUkr (convFI ts)
+{-# INLINE intersectInterReadyFCUkr2 #-}
+
+-- | Auxiliary printing function to define the line ending in some cases. Is taken from the
+-- Languages.UniquenessPeriods.Vector.General.DebugG module from the @phonetic-languages-general@ package
+newLineEnding :: String
+newLineEnding
+  | nativeNewline == LF = "\n"
+  | otherwise = "\r\n"
+  
+foldlI :: String -> [[ReadyForConstructionUkr]] -> [ReadyForConstructionUkr]
+foldlI ts jss@((!xs):ys:xss) 
+ | null pss = foldlI' ts qss
+ | null qss = foldlI' ts pss
+ | otherwise = intersectInterReadyFCUkr2 ts (foldlI' ts pss) (foldlI' ts qss) 
+  where (pss,qss) = partition (< [FSL []]) jss
+        foldlI' ts rss@(rs:ps:yss) = foldlI' ts (intersectInterReadyFCUkr2 ts rs ps : yss)
+        foldlI' ts ((!xs):_) = xs
+        foldlI' _ _ = []
+foldlI _ ((!xs):_) = xs
+foldlI _ _ = []
+
diff --git a/Phladiprelio/Ukrainian/SimpleConstraints.hs b/Phladiprelio/Ukrainian/SimpleConstraints.hs
new file mode 100644
--- /dev/null
+++ b/Phladiprelio/Ukrainian/SimpleConstraints.hs
@@ -0,0 +1,22 @@
+-- |
+-- Module      :  Phladiprelio.Ukrainian.SimpleConstraints
+-- Copyright   :  (c) Oleksandr Zhabenko 2020-2023
+-- License     :  MIT
+-- Stability   :  Experimental
+-- Maintainer  :  oleksandr.zhabenko@yahoo.com
+--
+-- Some code shared for different Main modules.
+
+{-# LANGUAGE NoImplicitPrelude #-}
+
+module Phladiprelio.Ukrainian.SimpleConstraints where
+
+import GHC.Base
+import Text.Show (show)
+import GHC.Num ((-))
+import GHC.List (concatMap)
+
+showB :: Int -> Bool -> String
+showB n bool
+ | n >= 2 && bool == True = 'B':show (n - 1) `mappend` concatMap show [0..n - 2]
+ | otherwise = ""
diff --git a/Phonetic/Languages/Common.hs b/Phonetic/Languages/Common.hs
deleted file mode 100644
--- a/Phonetic/Languages/Common.hs
+++ /dev/null
@@ -1,57 +0,0 @@
-{-# OPTIONS_GHC -threaded -rtsopts #-}
-{-# OPTIONS_HADDOCK show-extensions #-}
-{-# LANGUAGE BangPatterns, FlexibleContexts #-}
-
--- |
--- Module      :  Phonetic.Languages.Common
--- Copyright   :  (c) OleksandrZhabenko 2020-2021
--- License     :  MIT
--- Stability   :  Experimental
--- Maintainer  :  olexandr543@yahoo.com
---
---
---
-
-module Phonetic.Languages.Common (
-  fLinesN
-  , fLines
-  , fLinesNIO
-  , fLinesIO
-) where
-
-import Phonetic.Languages.Ukrainian.PrepareText
-import Data.Char (isAlpha,isSpace)
-import Data.Monoid (mappend)
-
-fLinesN :: Int -> Int -> String -> [String]
-fLinesN n !toOneLine ys = filter (any (\x -> isUkrainianL x && isAlpha x)) . prepareTextN n .
-  (\z -> if toOneLine == 1 then unls z else z) $ ys
-   -- the 'unls' is taken from the 'Data.List.words' and rewritten to be equal to 'unwords' . 'words'
-   where unls s  =  case dropWhile isSpace s of
-                      "" -> []
-                      s' -> w `mappend` (' ' : unls s'')
-                        where (w, s'') = break isSpace s'
-
-fLines :: Int -> String -> [String]
-fLines = fLinesN 7
-{-# INLINE fLines #-}
-
-fLinesNIO :: Int -> String -> IO ()
-fLinesNIO n ys = mapM_ putStrLn . map (\(i,x) -> show (i + 1) ++ "\t" ++ x) . helpG3 . indexedL "" .
-   filter (any (\x -> isUkrainianL x && isAlpha x)) . prepareTextN n $ ys
-
-fLinesIO :: String -> IO ()
-fLinesIO = fLinesNIO 7
-{-# INLINE fLinesIO #-}
-
--- | Is taken mostly from the Phonetic.Languages.Simplified.Lists.UniquenessPeriodsG module from the @phonetic-languages-simplified-common@ package.
-indexedL :: Foldable t => b -> t b -> [(Int, b)]
-indexedL y zs = foldr f v zs
-  where !v = [(length zs,y)]
-        f x ((j,z):ys) = (j-1,x):(j,z):ys
-{-# INLINE indexedL #-}
-
-helpG3 :: [a] -> [a]
-helpG3 xs
- | null xs = []
- | otherwise = init xs
diff --git a/Phonetic/Languages/Simplified/DeEnCoding.hs b/Phonetic/Languages/Simplified/DeEnCoding.hs
deleted file mode 100644
--- a/Phonetic/Languages/Simplified/DeEnCoding.hs
+++ /dev/null
@@ -1,150 +0,0 @@
-{-# OPTIONS_GHC -threaded -rtsopts #-}
-{-# OPTIONS_HADDOCK show-extensions #-}
-{-# LANGUAGE BangPatterns #-}
-
--- |
--- Module      :  Phonetic.Languages.Simplified.DeEnCoding
--- Copyright   :  (c) OleksandrZhabenko 2020-2022
--- License     :  MIT
--- Stability   :  Experimental
--- Maintainer  :  olexandr543@yahoo.com
---
--- Functions to encode and decode 'String' -> \['Int8'\] used in the Simple/Main.hs code.
--- Is taken from the @phonetic-languages-simplified-lists-examples@ package.
-
-module Phonetic.Languages.Simplified.DeEnCoding where
-
-import Data.Heap (Heap)
-import qualified Data.Heap as Heap
-import GHC.Int
-import Data.Foldable (foldl')
-import Data.List (sortBy,sort,partition)
-import System.IO
-import Data.Maybe (fromJust)
-import Numeric
-import Phonetic.Languages.Emphasis
-import Melodics.Ukrainian.ArrInt8 (FlowSound)
-import Languages.Phonetic.Ukrainian.Syllable.ArrInt8
-
---default (Int, Double)
-
-encodeToInt :: Ord a => [[a]] -> Int
-encodeToInt yss
- | null ks = -1
- | otherwise = fst . head $ ks
-  where ks = readHex (showHex (foldl' (\x y -> x * 16 + y) 0 . map (\(j,_) -> fromEnum j) . sortBy (\x y -> compare (snd x) (snd y)) . trans2 $ yss) $ "")
-{-# INLINABLE encodeToInt #-}
-
-
--- | Is taken mostly from the Phonetic.Languages.Simplified.Lists.UniquenessPeriodsG module from the @phonetic-languages-simplified-common@ package.
-indexedL :: Foldable t => b -> t b -> [(Int8, b)]
-indexedL y zs = foldr f v zs
-  where !v = [(toEnum (length zs + 1),y)]
-        f x ((j,z):ys) = (j-1,x):(j,z):ys
-{-# INLINE indexedL #-}
-
-trans2 :: [[a]] -> [(Int8, [a])]
-trans2 = init . indexedL []
-{-# INLINE trans2 #-}
-
-trans232 :: [[a]] -> [(Int, [a])]
-trans232 zs = init . foldr f v $ zs
-  where !v = [(length zs + 1,[])]
-        f x ((j,z):ys) = (j-1,x):(j,z):ys
-{-# INLINE trans232 #-}
-
-int2l :: Int -> [Int8]
-int2l n
- | n < 16 = [toEnum n]
- | otherwise = int2l n1 `mappend` [l]
-     where (!n1,!l0) = quotRem n 16
-           !l = toEnum l0
-{-# INLINABLE int2l #-}
-
--- | So for the strings consisting of no more than 10 words:
--- > decodeToStr (int2l . encodeToInt . words $ xs) xs == unwords . words $ xs
---
-decodeToStr :: [Int8] -> String -> String
-decodeToStr ys = unwords . map snd . sortBy (\x y -> compare (fst x) (fst y)) . zip ys . sort . words
-{-# INLINE decodeToStr #-}
-
--- | For the 'ReadyForConstructionUkr' that corresponds to the 'String' consisting of no more than 10 words.
---
-decodeToReadyFCUkr :: [Int8] -> ReadyForConstructionUkr -> ReadyForConstructionUkr
-decodeToReadyFCUkr ys (Str ts) = Str . unwords . map snd . sortBy (\x y -> compare (fst x) (fst y)) . zip ys . sort . words $ ts
-decodeToReadyFCUkr ys (FSL tsss) = FSL . map snd . sortBy (\x y -> compare (fst x) (fst y)) . zip ys . sort $ tsss
-{-# INLINE decodeToReadyFCUkr #-}
-
--- | Every 'String' consists of words with whitespace symbols in between.
-toHeap :: [String] -> Heap Int
-toHeap yss@(xs:xss)
-  | null xss = Heap.singleton . encodeToInt . words $ xs
-  | otherwise = Heap.fromList . map (encodeToInt . words) $ yss
-toHeap _ = Heap.empty
-{-# INLINE toHeap #-}
-
--- | Every 'ReadyForConstructionUkr' corresponds to the 'String' that consists of words with whitespace symbols in between.
--- The list must be consistent -- either 'FSL'-constructed or 'Str'-constructed.
-toHeapR :: [ReadyForConstructionUkr] -> Heap Int
-toHeapR yss@(xs@(Str ts):xss)
-  | null xss = Heap.singleton . encodeToInt . words $ ts
-  | otherwise = Heap.fromList . map (encodeToInt . words . fromJust . fromReadyFCUkrS) $ yss
-toHeapR yss@(xs@(FSL tsss):xss)
-  | null xss = Heap.singleton . encodeToInt $ tsss
-  | otherwise = Heap.fromList . map (encodeToInt . fromJust . fromReadyFCUkrF) $ yss  
-toHeapR _ = Heap.empty
-{-# INLINE toHeapR #-}
-
-fromHeap :: String -> Heap Int -> [String]
-fromHeap ys heap
- | Heap.null heap = []
- | otherwise = map (flip decodeToStr ys . int2l) . Heap.toUnsortedList $ heap
-{-# INLINE fromHeap #-}
-
-fromHeapReadyFCUkr :: ReadyForConstructionUkr -> Heap Int -> [ReadyForConstructionUkr]
-fromHeapReadyFCUkr ys heap
- | Heap.null heap = []
- | otherwise = map (flip decodeToReadyFCUkr ys . int2l) . Heap.toUnsortedList $ heap
-{-# INLINE fromHeapReadyFCUkr #-}
-
-intersectInterResults :: [String] -> [String] -> [String]
-intersectInterResults zss
- | null zss = const []
- | otherwise = fromHeap (head zss) . Heap.intersect (toHeap zss) . toHeap
-{-# INLINE intersectInterResults #-}
-
--- | It seems like it works, but it isn't. (??). The main reason is the hardness with defining convF to work properly.
-intersectInterReadyFCUkr :: (String -> [[FlowSound]]) -> [ReadyForConstructionUkr] -> [ReadyForConstructionUkr] -> [ReadyForConstructionUkr]
-intersectInterReadyFCUkr convF zss tss
- | null zss = []
- | null tss = []
- | (isStr . head $ tss) && (isStr . head $ zss) = fromHeapReadyFCUkr (head zss) . Heap.intersect (toHeapR zss) . toHeapR $ tss
- | (isFSL . head $ tss) && (isFSL . head $ zss) = fromHeapReadyFCUkr (head zss) . Heap.intersect (toHeapR zss) . toHeapR $ tss
- | isStr . head $ tss = fromHeapReadyFCUkr (head zss) . Heap.intersect (toHeapR zss) . toHeapR . map (FSL . convF . fromJust . fromReadyFCUkrS) $ tss
- | otherwise = fromHeapReadyFCUkr (head tss) . Heap.intersect (toHeapR . map (FSL . convF . fromJust . fromReadyFCUkrS) $ zss) . toHeapR $ tss
-{-# INLINE intersectInterReadyFCUkr #-}
-
-intersectInterReadyFCUkr2 :: String -> [ReadyForConstructionUkr] -> [ReadyForConstructionUkr] -> [ReadyForConstructionUkr]
-intersectInterReadyFCUkr2 ts = intersectInterReadyFCUkr (convFI ts)
-{-# INLINE intersectInterReadyFCUkr2 #-}
-
--- | Auxiliary printing function to define the line ending in some cases. Is taken from the
--- Languages.UniquenessPeriods.Vector.General.DebugG module from the @phonetic-languages-general@ package
-newLineEnding :: String
-newLineEnding
-  | nativeNewline == LF = "\n"
-  | otherwise = "\r\n"
-
-  
-foldlI :: String -> [[ReadyForConstructionUkr]] -> [ReadyForConstructionUkr]
-foldlI ts jss@((!xs):ys:xss) 
- | null pss = foldlI' ts qss
- | null qss = foldlI' ts pss
- | otherwise = intersectInterReadyFCUkr2 ts (foldlI' ts pss) (foldlI' ts qss) 
-  where (pss,qss) = partition (< [FSL []]) jss
-        foldlI' ts rss@(rs:ps:yss) = foldlI' ts (intersectInterReadyFCUkr2 ts rs ps : yss)
-        foldlI' ts ((!xs):_) = xs
-        foldlI' _ _ = []
-foldlI _ ((!xs):_) = xs
-foldlI _ _ = []
-
diff --git a/Phonetic/Languages/Simplified/SimpleConstraints.hs b/Phonetic/Languages/Simplified/SimpleConstraints.hs
deleted file mode 100644
--- a/Phonetic/Languages/Simplified/SimpleConstraints.hs
+++ /dev/null
@@ -1,17 +0,0 @@
--- |
--- Module      :  Phonetic.Languages.Simplified.SimpleConstraints
--- Copyright   :  (c) OleksandrZhabenko 2020
--- License     :  MIT
--- Stability   :  Experimental
--- Maintainer  :  olexandr543@yahoo.com
---
--- Some code shared for different Main modules.
-
-module Phonetic.Languages.Simplified.SimpleConstraints where
-
-import Data.Monoid
-
-showB :: Int -> Bool -> String
-showB n bool
- | n >= 2 && bool == True = 'B':show (n - 1) `mappend` concatMap show [0..n - 2]
- | otherwise = ""
diff --git a/phonetic-languages-simplified-examples-common.cabal b/phonetic-languages-simplified-examples-common.cabal
--- a/phonetic-languages-simplified-examples-common.cabal
+++ b/phonetic-languages-simplified-examples-common.cabal
@@ -2,24 +2,24 @@
 -- further documentation, see http://haskell.org/cabal/users-guide/
 
 name:                phonetic-languages-simplified-examples-common
-version:             0.5.1.0
+version:             0.6.2.0
 synopsis:            Some commonly used by phonetic-languages-simplified* series functions.
 description:         Are intended to be used by the phonetic-languages-simplified-lists-examples and phonetic-languages-simplified-examples-array packages.
 homepage:            https://hackage.haskell.org/package/phonetic-languages-simplified-examples-common
 license:             MIT
 license-file:        LICENSE
 author:              OleksandrZhabenko
-maintainer:          olexandr543@yahoo.com
-copyright:           (c) 2020-2022 Oleksandr Zhabenko
+maintainer:          oleksandr.zhabenko@yahoo.com
+copyright:           (c) 2020-2023 Oleksandr Zhabenko
 category:            Language, Math, Game
 build-type:          Simple
 extra-source-files:  CHANGELOG.md
 cabal-version:       >=1.10
 
 library
-  exposed-modules:     Phonetic.Languages.Simplified.DeEnCoding, Phonetic.Languages.Simplified.SimpleConstraints, Phonetic.Languages.Common
+  exposed-modules:     Phladiprelio.Ukrainian.DeEnCoding, Phladiprelio.Ukrainian.SimpleConstraints, Phladiprelio.Ukrainian.CommonE
   -- other-modules:
-  other-extensions:    BangPatterns
-  build-depends:       base >=4.8 && <5, heaps >= 0.3.6.1 && <1, phonetic-languages-ukrainian-array ==0.9.3.0, phonetic-languages-simplified-properties-array ==0.16.0.0, ukrainian-phonetics-basic-array ==0.6.0.0
+  other-extensions:    BangPatterns, NoImplicitPrelude
+  build-depends:       base >=4.13 && <5, heaps >= 0.3.6.1 && <1, phonetic-languages-ukrainian-array ==0.10.0.0, phonetic-languages-simplified-properties-array ==0.17.2.0, ukrainian-phonetics-basic-array ==0.7.0.0
   -- hs-source-dirs:
   default-language:    Haskell2010