diff --git a/CHANGELOG.md b/CHANGELOG.md
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -54,3 +54,25 @@
 ## 0.6.0.0 -- 2022-08-09
 
 * Sixth version. Added the functionality related to the Result2 data type in parallel to the old Result data type related one.
+
+## 0.6.1.0 -- 2022-09-13
+
+* Sixth version revised A. Updated the dependencies boundaries to use the new functionality.
+
+## 0.7.0.0 -- 2023-02-01
+
+* Seventh version. Switched to NoImplicitPrelude extension. Changed the names of the modules. Updated the dependencies boundaries.
+
+## 0.7.1.0 -- 2023-06-24
+
+* Seventh version revised A. Fixed constraints in the function declarations so that the code can
+  successfully be compiled for GHC-9.6.2 compiler.
+
+## 0.8.0.0 -- 2024-01-24
+
+* Eighth version. Added bug-tracker on Github. Generalized functions with specializing. Updated the dependencies, switched to minmax and monoid-insertleft instead of subG.
+
+ ## 0.9.0.0 -- 2024-03-08
+
+* Ninth version. Added a new module Data.ChooseLine with common functionality for PhLADiPreLiO mostly taken and rewritten from previous implementations. 
+
diff --git a/Data/ChooseLine.hs b/Data/ChooseLine.hs
new file mode 100644
--- /dev/null
+++ b/Data/ChooseLine.hs
@@ -0,0 +1,67 @@
+{-# OPTIONS_HADDOCK show-extensions #-}
+
+-- |
+-- Module      :  Data.ChooseLine
+-- Copyright   :  (c) Oleksandr Zhabenko 2021-2024
+-- License     :  MIT
+-- Stability   :  Experimental
+-- Maintainer  :  oleksandr.zhabenko@yahoo.com
+--
+-- General shared by phladiprelio-ukrainian-simple and phladiprelio-general-simple functionality to compare contents of the up to 14 files line-by-line 
+-- and to choose the resulting option. 
+
+{-# LANGUAGE NoImplicitPrelude, ScopedTypeVariables #-}
+
+module Data.ChooseLine where
+
+import GHC.Base
+import Data.Foldable (mapM_) 
+import Data.Maybe (fromMaybe) 
+import Text.Show (Show(..))
+import Text.Read (readMaybe)
+import System.IO (putStrLn, FilePath,getLine,appendFile,putStr,readFile)
+import Data.List
+import Data.Tuple (fst,snd)
+import Control.Exception (IOException,catch) 
+
+-- | Is rewritten from the <https://hackage.haskell.org/package/phonetic-languages-simplified-examples-array-0.21.0.0/docs/src/Phonetic.Languages.Lines.html#compareFilesToOneCommon>
+-- Given a list of different filepaths and the resulting filepath for the accumulated data provides a simple way to compare options of the lines in every file in the
+-- first argument and to choose that option for the resulting file. Therefore, the resulting file can combine options for lines from various sources.
+compareFilesToOneCommon 
+ :: Int -- ^ A number of files to be read and treated as sources of lines to choose from.
+ -> [FilePath] 
+ -> FilePath 
+ -> IO ()
+compareFilesToOneCommon n files file3 = do
+ contentss <- mapM ((\(j,ks) -> do {readFileIfAny ks >>= \fs -> return (j, zip [1..] . lines $ fs)})) . zip [1..] . take n $ files
+ compareF contentss file3
+   where compareF :: [(Int,[(Int,String)])] -> FilePath -> IO ()
+         compareF ysss file3 = mapM_ (\i -> do
+          putStr "Please, specify which variant to use as the result, "
+          putStrLn "maximum number is the quantity of the files from which the data is read: "
+          let strs = map (\(j,ks) -> (\ts -> if null ts then (j,"")
+                      else let (_,rs) = head ts in  (j,rs)) .
+                       filter ((== i) . fst) $ ks) ysss
+          putStrLn . unlines . map (\(i,xs) -> show i ++ ":\t" ++ xs) $ strs
+          ch <- getLine
+          let choice2 = fromMaybe 0 (readMaybe ch::Maybe Int)
+          toFileStr file3 ((\us -> if null us then [""] else [snd . head $ us]) . filter ((== choice2) . fst) $ strs)) $ [1..]
+
+{-| Inspired by: 'https://hackage.haskell.org/package/base-4.15.0.0/docs/src/GHC-IO.html#catch' 
+ Is taken from the 
+https://hackage.haskell.org/package/string-interpreter-0.8.0.0/docs/src/Interpreter.StringConversion.html#readFileIfAny
+to reduce general quantity of dependencies.
+Reads a textual file given by its 'FilePath' and returns its contents lazily. If there is
+some 'IOException' thrown or an empty file then returns just "". Raises an exception for the binary file. -}
+readFileIfAny :: FilePath -> IO String
+readFileIfAny file = catch (readFile file) (\(_ :: IOException) -> return "")
+{-# INLINE readFileIfAny #-}
+
+-- | Prints list of 'String's to the file as a multiline 'String' with default line ending. Uses 'appendFile' function inside.
+toFileStr ::
+  FilePath -- ^ The 'FilePath' to the file to be written in the 'AppendMode' (actually appended with) the information output.
+  -> [String] -- ^ Each element is appended on the new line to the file.
+  -> IO ()
+toFileStr file = appendFile file . unlines
+{-# INLINE toFileStr #-}
+
diff --git a/LICENSE b/LICENSE
--- a/LICENSE
+++ b/LICENSE
@@ -1,4 +1,4 @@
-Copyright (c) 2020-2022 OleksandrZhabenko
+Copyright (c) 2020-2024 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/DataG.hs b/Phladiprelio/DataG.hs
new file mode 100644
--- /dev/null
+++ b/Phladiprelio/DataG.hs
@@ -0,0 +1,301 @@
+{-# OPTIONS_HADDOCK show-extensions #-}
+
+-- |
+-- Module      :  Phladiprelio.DataG
+-- Copyright   :  (c) Oleksandr Zhabenko 2020-2024
+-- License     :  MIT
+-- Stability   :  Experimental
+-- Maintainer  :  oleksandr.zhabenko@yahoo.com
+--
+-- Simplified version of the @phonetic-languages-common@ and @phonetic-languages-general@ packages.
+-- Uses less dependencies.
+
+{-# LANGUAGE BangPatterns, FlexibleContexts, NoImplicitPrelude #-}
+
+module Phladiprelio.DataG where
+
+import GHC.Base
+import GHC.Num ((-))
+import GHC.Real
+import qualified Data.Foldable as F
+import Data.InsertLeft (InsertLeft(..),mapG,partitionG) 
+import Data.MinMax1
+import Data.Maybe (fromJust) 
+import Phladiprelio.Basis
+
+maximumEl
+  :: (F.Foldable t2, Ord c) => FuncRep2 (t a) b c
+  -> t2 (t a)
+  -> Result t a b c
+maximumEl !frep2 data0 =
+  let !l = F.maximumBy (\x y -> compare (getAC frep2 x) (getAC frep2 y)) data0
+      !m = getAB frep2 l
+      !tm = getBC frep2 m in R {line = l, propertiesF = m, transPropertiesF = tm}
+{-# INLINE maximumEl #-}
+{-# SPECIALIZE maximumEl :: (Ord c) => FuncRep2 [a] Double c -> [[a]] -> Result [] a Double c #-}
+
+-- | Is intended to be used for the structures with at least two elements, though it is not checked.
+minMaximumEls
+  :: (InsertLeft t2 (t a), Monoid (t2 (t a)), Ord (t a), Ord c) => FuncRep2 (t a) b c
+  -> t2 (t a)
+  -> (Result t a b c,Result t a b c)
+minMaximumEls !frep2 data0 =
+  let (!ln,!lx) = fromJust . minMax11By (\x y -> compare (getAC frep2 x) (getAC frep2 y)) $ data0
+      !mn = getAB frep2 ln
+      !mx = getAB frep2 lx
+      !tmn = getBC frep2 mn
+      !tmx = getBC frep2 mx in (R {line = ln, propertiesF = mn, transPropertiesF = tmn}, R {line = lx, propertiesF = mx, transPropertiesF = tmx})
+{-# INLINE minMaximumEls #-}
+{-# SPECIALIZE minMaximumEls :: (Ord a, Ord c) => FuncRep2 [a] Double c -> [[a]] -> (Result [] a Double c, Result [] a Double c) #-}
+
+maximumElR
+  :: (F.Foldable t2, Ord c) => t2 (Result t a b c)
+  -> Result t a b c
+maximumElR = F.maximumBy (\x y -> compare (transPropertiesF x) (transPropertiesF y))
+{-# INLINE maximumElR #-}
+{-# SPECIALIZE maximumElR :: (Ord c) => [Result [] a Double c] -> Result [] a Double c #-}
+
+-- | Is intended to be used for the structures with at least two elements, though it is not checked.
+minMaximumElRs
+  :: (InsertLeft t2 (Result t a b c), Monoid (t2 (Result t a b c)), Ord (t a), Ord b, Ord c) => t2 (Result t a b c)
+  -> (Result t a b c,Result t a b c)
+minMaximumElRs = fromJust . minMax11By (\x y -> compare (transPropertiesF x) (transPropertiesF y))
+{-# INLINE minMaximumElRs #-}
+{-# SPECIALIZE minMaximumElRs :: (Ord a, Ord c) => [Result [] a Double c] -> (Result [] a Double c, Result [] a Double c) #-}
+
+-----------------------------------------------------------------------------------
+
+-- | The second argument must be not empty for the function to work correctly.
+innerPartitioning
+  :: (InsertLeft t2 (t a), Monoid (t2 (t a)), InsertLeft t2 c, Monoid (t2 c), Ord c) => FuncRep2 (t a) b c
+  -> t2 (t a)
+  -> (t2 (t a), t2 (t a))
+innerPartitioning !frep2 data0 =
+  let !l = F.maximum . mapG (toTransPropertiesF' frep2) $ data0 in partitionG ((== l) . getAC frep2) data0
+{-# INLINE innerPartitioning #-}
+{-# SPECIALIZE innerPartitioning :: (Eq a, Ord c) => FuncRep2 [a] Double c -> [[a]] -> ([[a]], [[a]]) #-}
+
+-- | The first argument must be not empty for the function to work correctly.
+innerPartitioningR
+  :: (InsertLeft t2 (Result t a b c), Monoid (t2 (Result t a b c)), InsertLeft t2 c, Monoid (t2 c), Ord c) => t2 (Result t a b c)
+  -> (t2 (Result t a b c), t2 (Result t a b c))
+innerPartitioningR dataR =
+  let !l = F.maximum . mapG transPropertiesF $ dataR in partitionG ((== l) . transPropertiesF) dataR
+{-# INLINE innerPartitioningR #-}
+{-# SPECIALIZE innerPartitioningR :: (Eq a, Ord c) => [Result [] a Double c] -> ([Result [] a Double c], [Result [] a Double c]) #-}
+
+maximumGroupsClassification
+  :: (InsertLeft t2 (t a), Monoid (t2 (t a)), Ord c, InsertLeft t2 c, Monoid (t2 c), Integral d) => d
+  -> FuncRep2 (t a) b c
+  -> (t2 (t a), t2 (t a))
+  -> (t2 (t a), t2 (t a))
+maximumGroupsClassification !nGroups !frep2 (dataT,dataF)
+ | F.null dataF = (dataT,mempty)
+ | nGroups <= 0 = (dataT,dataF)
+ | otherwise = maximumGroupsClassification (nGroups - 1) frep2 (dataT `mappend` partT,partF)
+     where (!partT,!partF) = innerPartitioning frep2 dataF
+{-# NOINLINE maximumGroupsClassification #-}
+
+maximumGroupsClassification1
+  :: (InsertLeft t2 (t a), Monoid (t2 (t a)), Ord c, InsertLeft t2 c, Monoid (t2 c), Integral d) => d
+  -> FuncRep2 (t a) b c
+  -> t2 (t a)
+  -> (t2 (t a), t2 (t a))
+maximumGroupsClassification1 !nGroups !frep2 data0
+ | F.null data0 = (mempty,mempty)
+ | nGroups <= 0 = innerPartitioning frep2 data0
+ | otherwise = maximumGroupsClassification (nGroups - 1) frep2 . innerPartitioning frep2 $ data0
+{-# NOINLINE maximumGroupsClassification1 #-}
+
+maximumGroupsClassificationR2
+  :: (Eq a, Eq b, Eq (t a), InsertLeft t2 (Result t a b c), Monoid (t2 (Result t a b c)), Ord c, InsertLeft t2 c, Monoid (t2 c), Integral d) => d
+  -> (t2 (Result t a b c), t2 (Result t a b c))
+  -> (t2 (Result t a b c), t2 (Result t a b c))
+maximumGroupsClassificationR2 !nGroups (dataT,dataF)
+ | F.null dataF = (dataT,mempty)
+ | nGroups <= 0 = (dataT,dataF)
+ | otherwise = maximumGroupsClassificationR2 (nGroups - 1) (dataT `mappend` partT,partF)
+     where (!partT,!partF) = innerPartitioningR dataF
+{-# NOINLINE maximumGroupsClassificationR2 #-}
+
+maximumGroupsClassificationR
+  :: (Eq a, Eq b, Eq (t a), InsertLeft t2 (Result t a b c), Monoid (t2 (Result t a b c)), InsertLeft t2 c, Monoid (t2 c), Ord c, Integral d) => d
+  -> t2 (Result t a b c)
+  -> (t2 (Result t a b c), t2 (Result t a b c))
+maximumGroupsClassificationR !nGroups dataR
+ | F.null dataR = (mempty,mempty)
+ | nGroups <= 0 = innerPartitioningR dataR
+ | otherwise = maximumGroupsClassificationR2 (nGroups - 1) . innerPartitioningR $ dataR
+{-# NOINLINE maximumGroupsClassificationR #-}
+
+toResultR
+  :: FuncRep2 (t a) b c
+  -> t a
+  -> Result t a b c
+toResultR !frep2 !ys = R { line = ys, propertiesF = m, transPropertiesF = tm}
+  where !m = getAB frep2 ys
+        !tm = getBC frep2 m
+{-# INLINE toResultR #-}
+
+toPropertiesF'
+  :: FuncRep2 (t a) b c
+  -> t a
+  -> b
+toPropertiesF' !frep2 !ys = getAB frep2 ys
+{-# INLINE toPropertiesF' #-}
+
+toTransPropertiesF'
+  :: FuncRep2 (t a) b c
+  -> t a
+  -> c
+toTransPropertiesF' !frep2 !ys = getAC frep2 ys
+{-# INLINE toTransPropertiesF' #-}
+
+-- | The second argument must be not empty for the function to work correctly.
+partiR
+  :: (InsertLeft t2 (Result t a b c), Monoid (t2 (Result t a b c)), InsertLeft t2 c) => (c -> Bool)
+  -> t2 (Result t a b c)
+  -> (t2 (Result t a b c), t2 (Result t a b c))
+partiR p dataR = partitionG (p . transPropertiesF) dataR
+{-# INLINE partiR #-}
+{-# SPECIALIZE partiR :: (Eq a, Eq c) => (c -> Bool) -> [Result [] a Double c] -> ([Result [] a Double c], [Result [] a Double c])  #-}
+
+-----------------------------------------------------------
+
+maximumEl2
+  :: (F.Foldable t2, Ord c) => FuncRep2 a b c
+  -> t2 a
+  -> Result2 a b c
+maximumEl2 !frep2 data0 =
+  let !l = F.maximumBy (\x y -> compare (getAC frep2 x) (getAC frep2 y)) data0
+      !m = getAB frep2 l
+      !tm = getBC frep2 m in R2 {line2 = l, propertiesF2 = m, transPropertiesF2 = tm}
+{-# INLINE maximumEl2 #-}
+{-# SPECIALIZE maximumEl2 :: (Ord c) => FuncRep2 a Double c -> [a] -> Result2 a Double c  #-}
+
+-- | Is intended to be used with the structures with at least two elements, though it is not checked.
+minMaximumEls2
+  :: (InsertLeft t2 a, Monoid (t2 a), Ord a, Ord c) => FuncRep2 a b c
+  -> t2 a
+  -> (Result2 a b c,Result2 a b c)
+minMaximumEls2 !frep2 data0 =
+  let (!ln,!lx) = fromJust . minMax11By (\x y -> compare (getAC frep2 x) (getAC frep2 y)) $ data0
+      !mn = getAB frep2 ln
+      !mx = getAB frep2 lx
+      !tmn = getBC frep2 mn
+      !tmx = getBC frep2 mx in (R2 {line2 = ln, propertiesF2 = mn, transPropertiesF2 = tmn}, R2 {line2 = lx, propertiesF2 = mx, transPropertiesF2 = tmx})
+{-# INLINE minMaximumEls2 #-}
+{-# SPECIALIZE minMaximumEls2 :: (Ord a, Ord c) => FuncRep2 a Double c -> [a] -> (Result2 a Double c, Result2 a Double c) #-}
+
+maximumElR2
+  :: (F.Foldable t2, Ord c) => t2 (Result2 a b c)
+  -> Result2 a b c
+maximumElR2 = F.maximumBy (\x y -> compare (transPropertiesF2 x) (transPropertiesF2 y))
+{-# INLINE maximumElR2 #-}
+{-# SPECIALIZE maximumElR2 :: (Ord c) => [Result2 a Double c] -> Result2 a Double c #-}
+
+-- | Is intended to be used with the structures with at least two elements, though it is not checked.
+minMaximumElRs2
+  :: (InsertLeft t2 (Result2 a b c), Monoid (t2 (Result2 a b c)), Ord a, Ord b, Ord c) => t2 (Result2 a b c)
+  -> (Result2 a b c,Result2 a b c)
+minMaximumElRs2 = fromJust . minMax11By (\x y -> compare (transPropertiesF2 x) (transPropertiesF2 y))
+{-# INLINE minMaximumElRs2 #-}
+{-# SPECIALIZE minMaximumElRs2 :: (Ord a, Ord c) => [Result2 a Double c] -> (Result2 a Double c, Result2 a Double c) #-}
+
+-----------------------------------------------------------------------------------
+
+-- | The second argument must be not empty for the function to work correctly.
+innerPartitioning2
+  :: (InsertLeft t2 a, Monoid (t2 a), InsertLeft t2 c, Monoid (t2 c), Ord c) => FuncRep2 a b c
+  -> t2 a
+  -> (t2 a, t2 a)
+innerPartitioning2 !frep2 data0 =
+  let !l = F.maximum . mapG (toTransPropertiesF'2 frep2) $ data0 in partitionG ((== l) . getAC frep2) data0
+{-# INLINE innerPartitioning2 #-}
+{-# SPECIALIZE innerPartitioning2 :: (Eq a, Ord c) => FuncRep2 a Double c -> [a] -> ([a], [a])  #-}
+
+-- | The first argument must be not empty for the function to work correctly.
+innerPartitioningR2
+  :: (InsertLeft t2 (Result2 a b c), Monoid (t2 (Result2 a b c)), InsertLeft t2 c, Monoid (t2 c), Ord c) => t2 (Result2 a b c)
+  -> (t2 (Result2 a b c), t2 (Result2 a b c))
+innerPartitioningR2 dataR =
+  let !l = F.maximum . mapG transPropertiesF2 $ dataR in partitionG ((== l) . transPropertiesF2) dataR
+{-# INLINE innerPartitioningR2 #-}
+{-# SPECIALIZE innerPartitioningR2 :: (Eq a, Ord c) => [Result2 a Double c] -> ([Result2 a Double c], [Result2 a Double c]) #-}
+
+maximumGroupsClassification2
+  :: (InsertLeft t2 a, Monoid (t2 a), Ord c, InsertLeft t2 c, Monoid (t2 c), Integral d) => d
+  -> FuncRep2 a b c
+  -> (t2 a, t2 a)
+  -> (t2 a, t2 a)
+maximumGroupsClassification2 !nGroups !frep2 (dataT,dataF)
+ | F.null dataF = (dataT,mempty)
+ | nGroups <= 0 = (dataT,dataF)
+ | otherwise = maximumGroupsClassification2 (nGroups - 1) frep2 (dataT `mappend` partT,partF)
+     where (!partT,!partF) = innerPartitioning2 frep2 dataF
+{-# NOINLINE maximumGroupsClassification2 #-}
+
+maximumGroupsClassification12
+  :: (InsertLeft t2 a, Monoid (t2 a), Ord c, InsertLeft t2 c, Monoid (t2 c), Integral d) => d
+  -> FuncRep2 a b c
+  -> t2 a
+  -> (t2 a, t2 a)
+maximumGroupsClassification12 !nGroups !frep2 data0
+ | F.null data0 = (mempty,mempty)
+ | nGroups <= 0 = innerPartitioning2 frep2 data0
+ | otherwise = maximumGroupsClassification2 (nGroups - 1) frep2 . innerPartitioning2 frep2 $ data0
+{-# NOINLINE maximumGroupsClassification12 #-}
+
+maximumGroupsClassificationR2_2
+  :: (Eq a, Eq b, InsertLeft t2 (Result2 a b c), Monoid (t2 (Result2 a b c)), Ord c, InsertLeft t2 c, Monoid (t2 c), Integral d) => d
+  -> (t2 (Result2 a b c), t2 (Result2 a b c))
+  -> (t2 (Result2 a b c), t2 (Result2 a b c))
+maximumGroupsClassificationR2_2 !nGroups (dataT,dataF)
+ | F.null dataF = (dataT,mempty)
+ | nGroups <= 0 = (dataT,dataF)
+ | otherwise = maximumGroupsClassificationR2_2 (nGroups - 1) (dataT `mappend` partT,partF)
+     where (!partT,!partF) = innerPartitioningR2 dataF
+{-# NOINLINE maximumGroupsClassificationR2_2 #-}
+
+maximumGroupsClassificationR_2
+  :: (Eq a, Eq b, InsertLeft t2 (Result2 a b c), Monoid (t2 (Result2 a b c)), InsertLeft t2 c, Monoid (t2 c), Ord c, Integral d) => d
+  -> t2 (Result2 a b c)
+  -> (t2 (Result2 a b c), t2 (Result2 a b c))
+maximumGroupsClassificationR_2 !nGroups dataR
+ | F.null dataR = (mempty,mempty)
+ | nGroups <= 0 = innerPartitioningR2 dataR
+ | otherwise = maximumGroupsClassificationR2_2 (nGroups - 1) . innerPartitioningR2 $ dataR
+{-# NOINLINE maximumGroupsClassificationR_2 #-}
+
+toResultR2
+  :: FuncRep2 a b c
+  -> a
+  -> Result2 a b c
+toResultR2 !frep2 !y = R2 { line2 = y, propertiesF2 = m, transPropertiesF2 = tm}
+  where !m = getAB frep2 y
+        !tm = getBC frep2 m
+{-# INLINE toResultR2 #-}
+
+toPropertiesF'2
+  :: FuncRep2 a b c
+  -> a
+  -> b
+toPropertiesF'2 !frep2 !y = getAB frep2 y
+{-# INLINE toPropertiesF'2 #-}
+
+toTransPropertiesF'2
+  :: FuncRep2 a b c
+  -> a
+  -> c
+toTransPropertiesF'2 !frep2 !y = getAC frep2 y
+{-# INLINE toTransPropertiesF'2 #-}
+
+-- | The second argument must be not empty for the function to work correctly.
+partiR2
+  :: (InsertLeft t2 (Result2 a b c), Monoid (t2 (Result2 a b c)), InsertLeft t2 c) => (c -> Bool)
+  -> t2 (Result2 a b c)
+  -> (t2 (Result2 a b c), t2 (Result2 a b c))
+partiR2 p dataR = partitionG (p . transPropertiesF2) dataR
+{-# INLINE partiR2 #-}
+{-# SPECIALIZE partiR2 :: (Eq a, Eq c) => (c -> Bool) -> [Result2 a Double c] -> ([Result2 a Double c], [Result2 a Double c]) #-}
+
diff --git a/Phladiprelio/Partir.hs b/Phladiprelio/Partir.hs
new file mode 100644
--- /dev/null
+++ b/Phladiprelio/Partir.hs
@@ -0,0 +1,83 @@
+{-# OPTIONS_HADDOCK show-extensions #-}
+
+-- |
+-- Module      :  Phladiprelio.Partir
+-- Copyright   :  (c) Oleksandr Zhabenko 2022-2024
+-- License     :  MIT
+-- Stability   :  Experimental
+-- Maintainer  :  oleksandr.zhabenko@yahoo.com
+--
+-- 
+
+{-# LANGUAGE BangPatterns, FlexibleContexts, MultiParamTypeClasses, NoImplicitPrelude #-}
+
+module Phladiprelio.Partir where
+
+import GHC.Base
+import GHC.Num
+import GHC.Real
+import GHC.Float
+import qualified Data.Foldable as F
+import Data.InsertLeft (InsertLeft(..)) 
+import Phladiprelio.DataG
+import Phladiprelio.Basis
+import Data.Char (isDigit)
+import Data.List (uncons, filter, null)
+import Data.Maybe (fromJust, fromMaybe)
+import Text.Read (readMaybe)
+
+class F.Foldable t => ConstraintsG t a where
+  decodeCDouble :: t a -> Double -> Bool
+
+instance ConstraintsG [] Char where
+  decodeCDouble xs !y
+    | null xxs = True
+    | t < '2' = (if t == '0' then (>) else (<)) y (fromIntegral . fromMaybe 1 $ (readMaybe ts :: Maybe Integer))
+    | otherwise = getScale c cs t y
+       where xxs = filter isDigit xs
+             (t,ts) = fromJust . uncons $ xxs
+             (c,cs) = fromMaybe ('0',"1") . uncons $ ts
+             getScale c0 ws t0 y0  
+               | c0 == '1' = (ords t0) (logBase 10 y0) base
+               | c0 == '2' = (ords t0) (637.0 * atan y0) base -- atan Infinity * 637.0 \approx 1000.0
+               | c0 == '3' = (ords t0) (sin (k * y0)) (0.01 * base1)
+               | c0 == '4' = (ords t0) (cos (k * y0)) (0.01 * base1)
+               | c0 == '5' = (ords t0) (sin (k * y0)) (0.001 * base2)
+               | c0 == '6' = (ords t0) (cos (k * y0)) (0.001 * base2)
+               | c0 == '7' = (ords t0) (sin (k * y0)) (-0.01 * base1)
+               | c0 == '8' = (ords t0) (cos (k * y0)) (-0.01 * base1)
+               | otherwise = (ords t0) (y0 ** k) base1
+                  where base = fromIntegral . fromMaybe 1 $ (readMaybe ws :: Maybe Integer)
+                        ords t0
+                          | t0 == '2' = (>)
+                          | otherwise = (<)
+                        (w,wws) = fromMaybe ('2',"") . uncons $ ws
+                        base1 = fromIntegral . fromMaybe 50 $ (readMaybe wws :: Maybe Integer)
+                        base2 = fromIntegral . fromMaybe 500 $ (readMaybe wws :: Maybe Integer)
+                        k = fromIntegral . fromMaybe 2 $ (readMaybe [w] :: Maybe Integer)
+             
+partitioningR
+  :: (InsertLeft t2 (Result [] Char b Double), Monoid (t2 (Result [] Char b Double)), InsertLeft t2 Double, Monoid (t2 Double)) => String
+  -> t2 (Result [] Char b Double)
+  -> (t2 (Result [] Char b Double), t2 (Result [] Char b Double))
+partitioningR !xs dataR
+ | F.null dataR = (mempty,mempty)
+ | otherwise = partiR (decodeCDouble xs) dataR
+{-# INLINE partitioningR #-}
+{-# SPECIALIZE  partitioningR 
+  :: String
+  -> [Result [] Char Double Double]
+  -> ([Result [] Char Double Double], [Result [] Char Double Double])#-}
+
+partitioningR2
+  :: (InsertLeft t2 (Result2 a b Double), Monoid (t2 (Result2 a b Double)), InsertLeft t2 Double, Monoid (t2 Double)) => String
+  -> t2 (Result2 a b Double)
+  -> (t2 (Result2 a b Double), t2 (Result2 a b Double))
+partitioningR2 !xs dataR
+ | F.null dataR = (mempty,mempty)
+ | otherwise = partiR2 (decodeCDouble xs) dataR
+{-# INLINE partitioningR2 #-}
+{-# SPECIALIZE partitioningR2 :: (Eq a) => String
+  -> [Result2 a Double Double]
+  -> ([Result2 a Double Double], [Result2 a Double Double]) #-}
+
diff --git a/Phladiprelio/StrictVG.hs b/Phladiprelio/StrictVG.hs
new file mode 100644
--- /dev/null
+++ b/Phladiprelio/StrictVG.hs
@@ -0,0 +1,59 @@
+{-# OPTIONS_HADDOCK show-extensions #-}
+
+-- |
+-- Module      :  Phladiprelio.StrictVG
+-- Copyright   :  (c) Oleksandr Zhabenko 2020-2024
+-- License     :  MIT
+-- Stability   :  Experimental
+-- Maintainer  :  oleksandr.zhabenko@yahoo.com
+--
+-- Simplified version of the @phonetic-languages-common@ package.
+-- Uses less dependencies.
+
+{-# LANGUAGE BangPatterns, NoImplicitPrelude #-}
+
+module Phladiprelio.StrictVG (
+  -- * Working with lists
+  uniquenessVariants2GNBL
+  , uniquenessVariants2GNPBL
+) where
+
+import GHC.Base
+import GHC.Num ((-))
+import Phladiprelio.PermutationsArr
+import qualified Data.Foldable as F
+import Data.InsertLeft (InsertLeft(..)) 
+import GHC.Arr
+
+uniquenessVariants2GNBL ::
+  (Eq a, F.Foldable t, InsertLeft t a, Monoid (t a), Monoid (t (t a))) => a -- ^ The first most common element in the \"whitespace symbols\" structure
+  -> (t a -> [a]) -- ^ The function that is used internally to convert to the @[a]@ so that the function can process further the permutations
+  -> ((t (t a)) -> [[a]]) -- ^ The function that is used internally to convert to the @[[a]]@ so that the function can process further
+  -> ([a] -> t a) -- ^ The function that is used internally to convert to the needed representation so that the function can process further
+  -> [Array Int Int] -- ^ The permutations of 'Int' indices starting from 0 and up to n (n is probably less than 8).
+  -> t (t a) -- ^ Must be obtained as 'subG' @whspss xs@ or in equivalent way
+  -> [t a]
+uniquenessVariants2GNBL !hd f1 f2 f3 perms !subs = uniquenessVariants2GNPBL mempty mempty hd f1 f2 f3 perms subs
+{-# INLINE uniquenessVariants2GNBL #-}
+{-# SPECIALIZE uniquenessVariants2GNBL :: Char -> (String -> String) -> ([String] -> [String]) -> (String -> String) -> [Array Int Int] ->  [String] -> [String] #-}
+
+uniquenessVariants2GNPBL ::
+  (Eq a, F.Foldable t, InsertLeft t a, Monoid (t a), Monoid (t (t a))) => t a
+  -> t a
+  ->  a -- ^ The first most common element in the whitespace symbols structure
+  -> (t a -> [a]) -- ^ The function that is used internally to convert to the @[a]@ so that the function can process further the permutations
+  -> ((t (t a)) -> [[a]]) -- ^ The function that is used internally to convert to the @[[a]]@ so that the function can process further
+  -> ([a] -> t a) -- ^ The function that is used internally to convert to the needed representation that the function can process further
+  -> [Array Int Int] -- ^ The permutations of 'Int' indices starting from 0 and up to n (n is probably less than 8).
+  -> t (t a) -- ^ Must be obtained as @subG whspss xs@ or in equivalent way
+  -> [t a]
+uniquenessVariants2GNPBL !ts !us !hd f1 f2 f3 perms !subs
+  | F.null subs = mempty
+  | otherwise = map f3 ns
+   where !uss = (hd %@ us) %^ mempty
+         !base0 = map (hd %@) . f2 $ subs
+         !l = F.length base0
+         !baseArr = listArray (0,l - 1) base0
+         !ns = universalSetGL ts uss f1 f2 perms baseArr -- in map f3 ns
+{-# INLINE uniquenessVariants2GNPBL #-}
+{-# SPECIALIZE uniquenessVariants2GNPBL :: String -> String -> Char -> (String -> String) -> ([String] -> [String]) -> (String -> String) -> [Array Int Int] ->  [String] -> [String] #-}
diff --git a/Phonetic/Languages/Simplified/DataG/Base.hs b/Phonetic/Languages/Simplified/DataG/Base.hs
deleted file mode 100644
--- a/Phonetic/Languages/Simplified/DataG/Base.hs
+++ /dev/null
@@ -1,281 +0,0 @@
-{-# OPTIONS_HADDOCK show-extensions #-}
-
--- |
--- Module      :  Phonetic.Languages.Simplified.DataG.Base
--- Copyright   :  (c) OleksandrZhabenko 2020-2022
--- License     :  MIT
--- Stability   :  Experimental
--- Maintainer  :  olexandr543@yahoo.com
---
--- Simplified version of the @phonetic-languages-common@ and @phonetic-languages-general@ packages.
--- Uses less dependencies.
-
-{-# LANGUAGE BangPatterns, FlexibleContexts #-}
-
-module Phonetic.Languages.Simplified.DataG.Base where
-
-import qualified Data.Foldable as F
-import Data.Monoid
-import Data.SubG
-import Data.MinMax.Preconditions
-import Phonetic.Languages.Basis
-
-maximumEl
-  :: (Foldable t2, Ord c) => FuncRep2 (t a) b c
-  -> t2 (t a)
-  -> Result t a b c
-maximumEl !frep2 data0 =
-  let !l = F.maximumBy (\x y -> compare (getAC frep2 x) (getAC frep2 y)) data0
-      !m = getAB frep2 l
-      !tm = getBC frep2 m in R {line = l, propertiesF = m, transPropertiesF = tm}
-{-# INLINE maximumEl #-}
-
-minMaximumEls
-  :: (InsertLeft t2 (t a), Monoid (t2 (t a)), Ord (t a), Ord c) => FuncRep2 (t a) b c
-  -> t2 (t a)
-  -> (Result t a b c,Result t a b c)
-minMaximumEls !frep2 data0 =
-  let (!ln,!lx) = minMax11ByC (\x y -> compare (getAC frep2 x) (getAC frep2 y)) data0
-      !mn = getAB frep2 ln
-      !mx = getAB frep2 lx
-      !tmn = getBC frep2 mn
-      !tmx = getBC frep2 mx in (R {line = ln, propertiesF = mn, transPropertiesF = tmn}, R {line = lx, propertiesF = mx, transPropertiesF = tmx})
-{-# INLINE minMaximumEls #-}
-
-maximumElR
-  :: (Foldable t2, Ord c) => t2 (Result t a b c)
-  -> Result t a b c
-maximumElR = F.maximumBy (\x y -> compare (transPropertiesF x) (transPropertiesF y))
-{-# INLINE maximumElR #-}
-
-minMaximumElRs
-  :: (InsertLeft t2 (Result t a b c), Monoid (t2 (Result t a b c)), Ord (t a), Ord b, Ord c) => t2 (Result t a b c)
-  -> (Result t a b c,Result t a b c)
-minMaximumElRs = minMax11ByC (\x y -> compare (transPropertiesF x) (transPropertiesF y))
-{-# INLINE minMaximumElRs #-}
-
------------------------------------------------------------------------------------
-
--- | The second argument must be not empty for the function to work correctly.
-innerPartitioning
-  :: (InsertLeft t2 (t a), Monoid (t2 (t a)), InsertLeft t2 c, Monoid (t2 c), Ord c) => FuncRep2 (t a) b c
-  -> t2 (t a)
-  -> (t2 (t a), t2 (t a))
-innerPartitioning !frep2 data0 =
-  let !l = F.maximum . mapG (toTransPropertiesF' frep2) $ data0 in partitionG ((== l) . getAC frep2) data0
-{-# INLINE innerPartitioning #-}
-
--- | The first argument must be not empty for the function to work correctly.
-innerPartitioningR
-  :: (InsertLeft t2 (Result t a b c), Monoid (t2 (Result t a b c)), InsertLeft t2 c, Monoid (t2 c), Ord c) => t2 (Result t a b c)
-  -> (t2 (Result t a b c), t2 (Result t a b c))
-innerPartitioningR dataR =
-  let !l = F.maximum . mapG transPropertiesF $ dataR in partitionG ((== l) . transPropertiesF) dataR
-{-# INLINE innerPartitioningR #-}
-
-maximumGroupsClassification
-  :: (InsertLeft t2 (t a), Monoid (t2 (t a)), Ord c, InsertLeft t2 c, Monoid (t2 c), Integral d) => d
-  -> FuncRep2 (t a) b c
-  -> (t2 (t a), t2 (t a))
-  -> (t2 (t a), t2 (t a))
-maximumGroupsClassification !nGroups !frep2 (dataT,dataF)
- | F.null dataF = (dataT,mempty)
- | nGroups <= 0 = (dataT,dataF)
- | otherwise = maximumGroupsClassification (nGroups - 1) frep2 (dataT `mappend` partT,partF)
-     where (!partT,!partF) = innerPartitioning frep2 dataF
-{-# NOINLINE maximumGroupsClassification #-}
-
-maximumGroupsClassification1
-  :: (InsertLeft t2 (t a), Monoid (t2 (t a)), Ord c, InsertLeft t2 c, Monoid (t2 c), Integral d) => d
-  -> FuncRep2 (t a) b c
-  -> t2 (t a)
-  -> (t2 (t a), t2 (t a))
-maximumGroupsClassification1 !nGroups !frep2 data0
- | F.null data0 = (mempty,mempty)
- | nGroups <= 0 = innerPartitioning frep2 data0
- | otherwise = maximumGroupsClassification (nGroups - 1) frep2 . innerPartitioning frep2 $ data0
-{-# NOINLINE maximumGroupsClassification1 #-}
-
-maximumGroupsClassificationR2
-  :: (InsertLeft t2 (Result t a b c), Monoid (t2 (Result t a b c)), Ord c, InsertLeft t2 c, Monoid (t2 c), Integral d) => d
-  -> (t2 (Result t a b c), t2 (Result t a b c))
-  -> (t2 (Result t a b c), t2 (Result t a b c))
-maximumGroupsClassificationR2 !nGroups (dataT,dataF)
- | F.null dataF = (dataT,mempty)
- | nGroups <= 0 = (dataT,dataF)
- | otherwise = maximumGroupsClassificationR2 (nGroups - 1) (dataT `mappend` partT,partF)
-     where (!partT,!partF) = innerPartitioningR dataF
-{-# NOINLINE maximumGroupsClassificationR2 #-}
-
-maximumGroupsClassificationR
-  :: (InsertLeft t2 (Result t a b c), Monoid (t2 (Result t a b c)), InsertLeft t2 c, Monoid (t2 c), Ord c, Integral d) => d
-  -> t2 (Result t a b c)
-  -> (t2 (Result t a b c), t2 (Result t a b c))
-maximumGroupsClassificationR !nGroups dataR
- | F.null dataR = (mempty,mempty)
- | nGroups <= 0 = innerPartitioningR dataR
- | otherwise = maximumGroupsClassificationR2 (nGroups - 1) . innerPartitioningR $ dataR
-{-# NOINLINE maximumGroupsClassificationR #-}
-
-toResultR
-  :: FuncRep2 (t a) b c
-  -> t a
-  -> Result t a b c
-toResultR !frep2 !ys = R { line = ys, propertiesF = m, transPropertiesF = tm}
-  where !m = getAB frep2 ys
-        !tm = getBC frep2 m
-{-# INLINE toResultR #-}
-
-toPropertiesF'
-  :: FuncRep2 (t a) b c
-  -> t a
-  -> b
-toPropertiesF' !frep2 !ys = getAB frep2 ys
-{-# INLINE toPropertiesF' #-}
-
-toTransPropertiesF'
-  :: FuncRep2 (t a) b c
-  -> t a
-  -> c
-toTransPropertiesF' !frep2 !ys = getAC frep2 ys
-{-# INLINE toTransPropertiesF' #-}
-
--- | The second argument must be not empty for the function to work correctly.
-partiR
-  :: (InsertLeft t2 (Result t a b c), Monoid (t2 (Result t a b c)), InsertLeft t2 c) => (c -> Bool)
-  -> t2 (Result t a b c)
-  -> (t2 (Result t a b c), t2 (Result t a b c))
-partiR p dataR = partitionG (p . transPropertiesF) dataR
-{-# INLINE partiR #-}
-
------------------------------------------------------------
-
-maximumEl2
-  :: (Foldable t2, Ord c) => FuncRep2 a b c
-  -> t2 a
-  -> Result2 a b c
-maximumEl2 !frep2 data0 =
-  let !l = F.maximumBy (\x y -> compare (getAC frep2 x) (getAC frep2 y)) data0
-      !m = getAB frep2 l
-      !tm = getBC frep2 m in R2 {line2 = l, propertiesF2 = m, transPropertiesF2 = tm}
-{-# INLINE maximumEl2 #-}
-
-minMaximumEls2
-  :: (InsertLeft t2 a, Monoid (t2 a), Ord a, Ord c) => FuncRep2 a b c
-  -> t2 a
-  -> (Result2 a b c,Result2 a b c)
-minMaximumEls2 !frep2 data0 =
-  let (!ln,!lx) = minMax11ByC (\x y -> compare (getAC frep2 x) (getAC frep2 y)) data0
-      !mn = getAB frep2 ln
-      !mx = getAB frep2 lx
-      !tmn = getBC frep2 mn
-      !tmx = getBC frep2 mx in (R2 {line2 = ln, propertiesF2 = mn, transPropertiesF2 = tmn}, R2 {line2 = lx, propertiesF2 = mx, transPropertiesF2 = tmx})
-{-# INLINE minMaximumEls2 #-}
-
-maximumElR2
-  :: (Foldable t2, Ord c) => t2 (Result2 a b c)
-  -> Result2 a b c
-maximumElR2 = F.maximumBy (\x y -> compare (transPropertiesF2 x) (transPropertiesF2 y))
-{-# INLINE maximumElR2 #-}
-
-minMaximumElRs2
-  :: (InsertLeft t2 (Result2 a b c), Monoid (t2 (Result2 a b c)), Ord a, Ord b, Ord c) => t2 (Result2 a b c)
-  -> (Result2 a b c,Result2 a b c)
-minMaximumElRs2 = minMax11ByC (\x y -> compare (transPropertiesF2 x) (transPropertiesF2 y))
-{-# INLINE minMaximumElRs2 #-}
-
------------------------------------------------------------------------------------
-
--- | The second argument must be not empty for the function to work correctly.
-innerPartitioning2
-  :: (InsertLeft t2 a, Monoid (t2 a), InsertLeft t2 c, Monoid (t2 c), Ord c) => FuncRep2 a b c
-  -> t2 a
-  -> (t2 a, t2 a)
-innerPartitioning2 !frep2 data0 =
-  let !l = F.maximum . mapG (toTransPropertiesF'2 frep2) $ data0 in partitionG ((== l) . getAC frep2) data0
-{-# INLINE innerPartitioning2 #-}
-
--- | The first argument must be not empty for the function to work correctly.
-innerPartitioningR2
-  :: (InsertLeft t2 (Result2 a b c), Monoid (t2 (Result2 a b c)), InsertLeft t2 c, Monoid (t2 c), Ord c) => t2 (Result2 a b c)
-  -> (t2 (Result2 a b c), t2 (Result2 a b c))
-innerPartitioningR2 dataR =
-  let !l = F.maximum . mapG transPropertiesF2 $ dataR in partitionG ((== l) . transPropertiesF2) dataR
-{-# INLINE innerPartitioningR2 #-}
-
-maximumGroupsClassification2
-  :: (InsertLeft t2 a, Monoid (t2 a), Ord c, InsertLeft t2 c, Monoid (t2 c), Integral d) => d
-  -> FuncRep2 a b c
-  -> (t2 a, t2 a)
-  -> (t2 a, t2 a)
-maximumGroupsClassification2 !nGroups !frep2 (dataT,dataF)
- | F.null dataF = (dataT,mempty)
- | nGroups <= 0 = (dataT,dataF)
- | otherwise = maximumGroupsClassification2 (nGroups - 1) frep2 (dataT `mappend` partT,partF)
-     where (!partT,!partF) = innerPartitioning2 frep2 dataF
-{-# NOINLINE maximumGroupsClassification2 #-}
-
-maximumGroupsClassification12
-  :: (InsertLeft t2 a, Monoid (t2 a), Ord c, InsertLeft t2 c, Monoid (t2 c), Integral d) => d
-  -> FuncRep2 a b c
-  -> t2 a
-  -> (t2 a, t2 a)
-maximumGroupsClassification12 !nGroups !frep2 data0
- | F.null data0 = (mempty,mempty)
- | nGroups <= 0 = innerPartitioning2 frep2 data0
- | otherwise = maximumGroupsClassification2 (nGroups - 1) frep2 . innerPartitioning2 frep2 $ data0
-{-# NOINLINE maximumGroupsClassification12 #-}
-
-maximumGroupsClassificationR2_2
-  :: (InsertLeft t2 (Result2 a b c), Monoid (t2 (Result2 a b c)), Ord c, InsertLeft t2 c, Monoid (t2 c), Integral d) => d
-  -> (t2 (Result2 a b c), t2 (Result2 a b c))
-  -> (t2 (Result2 a b c), t2 (Result2 a b c))
-maximumGroupsClassificationR2_2 !nGroups (dataT,dataF)
- | F.null dataF = (dataT,mempty)
- | nGroups <= 0 = (dataT,dataF)
- | otherwise = maximumGroupsClassificationR2_2 (nGroups - 1) (dataT `mappend` partT,partF)
-     where (!partT,!partF) = innerPartitioningR2 dataF
-{-# NOINLINE maximumGroupsClassificationR2_2 #-}
-
-maximumGroupsClassificationR_2
-  :: (InsertLeft t2 (Result2 a b c), Monoid (t2 (Result2 a b c)), InsertLeft t2 c, Monoid (t2 c), Ord c, Integral d) => d
-  -> t2 (Result2 a b c)
-  -> (t2 (Result2 a b c), t2 (Result2 a b c))
-maximumGroupsClassificationR_2 !nGroups dataR
- | F.null dataR = (mempty,mempty)
- | nGroups <= 0 = innerPartitioningR2 dataR
- | otherwise = maximumGroupsClassificationR2_2 (nGroups - 1) . innerPartitioningR2 $ dataR
-{-# NOINLINE maximumGroupsClassificationR_2 #-}
-
-toResultR2
-  :: FuncRep2 a b c
-  -> a
-  -> Result2 a b c
-toResultR2 !frep2 !y = R2 { line2 = y, propertiesF2 = m, transPropertiesF2 = tm}
-  where !m = getAB frep2 y
-        !tm = getBC frep2 m
-{-# INLINE toResultR2 #-}
-
-toPropertiesF'2
-  :: FuncRep2 a b c
-  -> a
-  -> b
-toPropertiesF'2 !frep2 !y = getAB frep2 y
-{-# INLINE toPropertiesF'2 #-}
-
-toTransPropertiesF'2
-  :: FuncRep2 a b c
-  -> a
-  -> c
-toTransPropertiesF'2 !frep2 !y = getAC frep2 y
-{-# INLINE toTransPropertiesF'2 #-}
-
--- | The second argument must be not empty for the function to work correctly.
-partiR2
-  :: (InsertLeft t2 (Result2 a b c), Monoid (t2 (Result2 a b c)), InsertLeft t2 c) => (c -> Bool)
-  -> t2 (Result2 a b c)
-  -> (t2 (Result2 a b c), t2 (Result2 a b c))
-partiR2 p dataR = partitionG (p . transPropertiesF2) dataR
-{-# INLINE partiR2 #-}
-
-
diff --git a/Phonetic/Languages/Simplified/DataG/Partir.hs b/Phonetic/Languages/Simplified/DataG/Partir.hs
deleted file mode 100644
--- a/Phonetic/Languages/Simplified/DataG/Partir.hs
+++ /dev/null
@@ -1,74 +0,0 @@
-{-# OPTIONS_HADDOCK show-extensions #-}
-
--- |
--- Module      :  Phonetic.Languages.Simplified.DataG.Partir
--- Copyright   :  (c) OleksandrZhabenko 2022
--- License     :  MIT
--- Stability   :  Experimental
--- Maintainer  :  olexandr543@yahoo.com
---
--- 
-
-{-# LANGUAGE BangPatterns, FlexibleContexts, MultiParamTypeClasses #-}
-
-module Phonetic.Languages.Simplified.DataG.Partir where
-
-import qualified Data.Foldable as F
-import Data.Monoid
-import Data.SubG
-import Data.MinMax.Preconditions
-import Phonetic.Languages.Simplified.DataG.Base
-import Phonetic.Languages.Basis
-import Data.Char (isDigit)
-import Data.List (uncons)
-import Data.Maybe (fromJust, fromMaybe)
-import Text.Read (readMaybe)
-
-class Foldable t => ConstraintsG t a where
-  decodeCDouble :: t a -> Double -> Bool
-
-instance ConstraintsG [] Char where
-  decodeCDouble xs !y
-    | null xxs = True
-    | t < '2' = (if t == '0' then (>) else (<)) y (fromIntegral . fromMaybe 1 $ (readMaybe ts :: Maybe Integer))
-    | otherwise = getScale c cs t y
-       where xxs = filter isDigit xs
-             (t,ts) = fromJust . uncons $ xxs
-             (c,cs) = fromMaybe ('0',"1") . uncons $ ts
-             getScale c0 ws t0 y0  
-               | c0 == '1' = (ords t0) (logBase 10 y0) base
-               | c0 == '2' = (ords t0) (637.0 * atan y0) base -- atan Infinity * 637.0 \approx 1000.0
-               | c0 == '3' = (ords t0) (sin (k * y0)) (0.01 * base1)
-               | c0 == '4' = (ords t0) (cos (k * y0)) (0.01 * base1)
-               | c0 == '5' = (ords t0) (sin (k * y0)) (0.001 * base2)
-               | c0 == '6' = (ords t0) (cos (k * y0)) (0.001 * base2)
-               | c0 == '7' = (ords t0) (sin (k * y0)) (-0.01 * base1)
-               | c0 == '8' = (ords t0) (cos (k * y0)) (-0.01 * base1)
-               | otherwise = (ords t0) (y0 ** k) base1
-                  where base = fromIntegral . fromMaybe 1 $ (readMaybe ws :: Maybe Integer)
-                        ords t0
-                          | t0 == '2' = (>)
-                          | otherwise = (<)
-                        (w,wws) = fromMaybe ('2',"") . uncons $ ws
-                        base1 = fromIntegral . fromMaybe 50 $ (readMaybe wws :: Maybe Integer)
-                        base2 = fromIntegral . fromMaybe 500 $ (readMaybe wws :: Maybe Integer)
-                        k = fromIntegral . fromMaybe 2 $ (readMaybe [w] :: Maybe Integer)
-             
-partitioningR
-  :: (InsertLeft t2 (Result [] Char b Double), Monoid (t2 (Result [] Char b Double)), InsertLeft t2 Double, Monoid (t2 Double)) => String
-  -> t2 (Result [] Char b Double)
-  -> (t2 (Result [] Char b Double), t2 (Result [] Char b Double))
-partitioningR !xs dataR
- | F.null dataR = (mempty,mempty)
- | otherwise = partiR (decodeCDouble xs) dataR
-{-# INLINABLE partitioningR #-}
-
-partitioningR2
-  :: (InsertLeft t2 (Result2 a b Double), Monoid (t2 (Result2 a b Double)), InsertLeft t2 Double, Monoid (t2 Double)) => String
-  -> t2 (Result2 a b Double)
-  -> (t2 (Result2 a b Double), t2 (Result2 a b Double))
-partitioningR2 !xs dataR
- | F.null dataR = (mempty,mempty)
- | otherwise = partiR2 (decodeCDouble xs) dataR
-{-# INLINABLE partitioningR2 #-}
-
diff --git a/Phonetic/Languages/Simplified/StrictVG/Base.hs b/Phonetic/Languages/Simplified/StrictVG/Base.hs
deleted file mode 100644
--- a/Phonetic/Languages/Simplified/StrictVG/Base.hs
+++ /dev/null
@@ -1,56 +0,0 @@
-{-# OPTIONS_HADDOCK show-extensions #-}
-
--- |
--- Module      :  Phonetic.Languages.Simplified.StrictVG.Base
--- Copyright   :  (c) OleksandrZhabenko 2020-2021
--- License     :  MIT
--- Stability   :  Experimental
--- Maintainer  :  olexandr543@yahoo.com
---
--- Simplified version of the @phonetic-languages-common@ package.
--- Uses less dependencies.
-
-{-# LANGUAGE BangPatterns #-}
-
-module Phonetic.Languages.Simplified.StrictVG.Base (
-  -- * Working with lists
-  uniquenessVariants2GNBL
-  , uniquenessVariants2GNPBL
-) where
-
-import Phonetic.Languages.Permutations.Arr
-import qualified Data.Foldable as F
-import Data.SubG
-import GHC.Arr
-import Data.Monoid
-
-uniquenessVariants2GNBL ::
-  (Eq a, Foldable t, InsertLeft t a, Monoid (t a), Monoid (t (t a))) => a -- ^ The first most common element in the \"whitespace symbols\" structure
-  -> (t a -> [a]) -- ^ The function that is used internally to convert to the @[a]@ so that the function can process further the permutations
-  -> ((t (t a)) -> [[a]]) -- ^ The function that is used internally to convert to the @[[a]]@ so that the function can process further
-  -> ([a] -> t a) -- ^ The function that is used internally to convert to the needed representation so that the function can process further
-  -> [Array Int Int] -- ^ The permutations of 'Int' indices starting from 0 and up to n (n is probably less than 8).
-  -> t (t a) -- ^ Must be obtained as 'subG' @whspss xs@
-  -> [t a]
-uniquenessVariants2GNBL !hd f1 f2 f3 perms !subs = uniquenessVariants2GNPBL mempty mempty hd f1 f2 f3 perms subs
-{-# INLINE uniquenessVariants2GNBL #-}
-
-uniquenessVariants2GNPBL ::
-  (Eq a, Foldable t, InsertLeft t a, Monoid (t a), Monoid (t (t a))) => t a
-  -> t a
-  ->  a -- ^ The first most common element in the whitespace symbols structure
-  -> (t a -> [a]) -- ^ The function that is used internally to convert to the @[a]@ so that the function can process further the permutations
-  -> ((t (t a)) -> [[a]]) -- ^ The function that is used internally to convert to the @[[a]]@ so that the function can process further
-  -> ([a] -> t a) -- ^ The function that is used internally to convert to the needed representation that the function can process further
-  -> [Array Int Int] -- ^ The permutations of 'Int' indices starting from 0 and up to n (n is probably less than 8).
-  -> t (t a) -- ^ Must be obtained as @subG whspss xs@
-  -> [t a]
-uniquenessVariants2GNPBL !ts !us !hd f1 f2 f3 perms !subs
-  | F.null subs = mempty
-  | otherwise = map f3 ns
-   where !uss = (hd %@ us) %^ mempty
-         !base0 = map (hd %@) . f2 $ subs
-         !l = length base0
-         !baseArr = listArray (0,l - 1) base0
-         !ns = universalSetGL ts uss f1 f2 perms baseArr -- in map f3 ns
-{-# INLINE uniquenessVariants2GNPBL #-}
diff --git a/README.md b/README.md
new file mode 100644
--- /dev/null
+++ b/README.md
@@ -0,0 +1,24 @@
+ Devotion
+ ========
+
+The author would like to devote this project to support the [Foundation Gastrostars](https://gastrostars.nl).
+
+The foundation founder is [Emma Kok](https://www.emmakok.nl).
+
+On the 06/01/2024 there is Sophie's Kok, a sister of Emma Kok, 19th Birthday (she is 18). Therefore, the version 0.8.0.0 is additionally devoted also to her. On the 22/01/2023 there is Day of Unity of Ukraine, and on the 23/01/2024 the Orthodox Christians have memory of St. Paulinus of Nola.
+
+On the 08/03/2024 there is International Women's Day.
+
+Besides, you can support Ukraine and Ukrainian people. 
+
+All support is welcome, including donations for the needs of the Ukrainian army, IDPs and refugees.
+
+If you would like to share some financial support with Gastrostars, please, contact the mentioned foundation
+using the URL:
+
+[Contact Foundation GASTROSTARS](https://gastrostars.nl/hou-mij-op-de-hoogte)
+
+or 
+
+[Donation Page](https://gastrostars.nl/doneren)
+
diff --git a/phonetic-languages-simplified-base.cabal b/phonetic-languages-simplified-base.cabal
--- a/phonetic-languages-simplified-base.cabal
+++ b/phonetic-languages-simplified-base.cabal
@@ -3,24 +3,26 @@
 -- http://haskell.org/cabal/users-guide/
 
 name:                phonetic-languages-simplified-base
-version:             0.6.0.0
+version:             0.9.0.0
 synopsis:            A basics of the phonetic-languages functionality that can be groupped.
-description:         The  common for different realizations functionality. Just the necessary one.
+description:         The  common for different realizations of PhLADiPreLiO functionality. Just the necessary one.
 homepage:            https://hackage.haskell.org/package/phonetic-languages-simlified-base
+bug-reports:         https://github.com/Oleksandr-Zhabenko/phonetic-languages-simplified-base/issues
 license:             MIT
 license-file:        LICENSE
 author:              OleksandrZhabenko
-maintainer:          olexandr543@yahoo.com
+maintainer:          oleksandr.zhabenko@yahoo.com
 copyright:           Oleksandr Zhabenko
 category:            Language,Math,Game
 build-type:          Simple
-extra-source-files:  CHANGELOG.md
+extra-source-files:  CHANGELOG.md, README.md
 cabal-version:       >=1.10
 
 library
-  exposed-modules:     Phonetic.Languages.Simplified.DataG.Base, Phonetic.Languages.Simplified.StrictVG.Base, Phonetic.Languages.Simplified.DataG.Partir
+  exposed-modules:     Phladiprelio.DataG, Phladiprelio.StrictVG, Phladiprelio.Partir, Data.ChooseLine
   -- other-modules:
-  other-extensions:    BangPatterns, FlexibleContexts, MultiParamTypeClasses
-  build-depends:       base >=4.8 && <5, subG ==0.5.3.0, phonetic-languages-permutations-array ==0.3.4.0, phonetic-languages-basis ==0.1.1.0
+  -- ghc-options:         -Wall
+  other-extensions:    BangPatterns, FlexibleContexts, MultiParamTypeClasses, NoImplicitPrelude, ScopedTypeVariables
+  build-depends:       base >=4.13 && <5, monoid-insertleft ==0.1.0.1, phonetic-languages-permutations-array ==0.5.0.0, phonetic-languages-basis ==0.3.0.0, minmax ==0.1.1.0
   -- hs-source-dirs:
   default-language:    Haskell2010