diff --git a/ChangeLog.md b/ChangeLog.md
--- a/ChangeLog.md
+++ b/ChangeLog.md
@@ -249,3 +249,6 @@
 
 * Fifteenth version revised F. Changed the bounds of the dependencies so that now also GHC 8.10* series are supported.
 
+## 0.15.5.0 -- 2020-05-26
+
+* Fifteenth version revised G. Some code improvements.
diff --git a/Main.hs b/Main.hs
--- a/Main.hs
+++ b/Main.hs
@@ -39,7 +39,7 @@
        putStr "list-of-produced-sound-representations (if any) -- a list of sound representations, which the program will try to produce while being executed. "
        putStrLn "The default one (if not specified) is a full range of needed sound representations. "
     "-v" -> do
-       putStrLn "mmsyn7ukr version: 0.15.3.0"
+       putStrLn "mmsyn7ukr version: 0.15.5.0"
     "-t" -> do
        putStrLn "The program plays now a service sound for a 0.5 second. It uses just that duration for a pause before you can record a sound representation further."
        path0 <- getDataFileName "y.wav"
diff --git a/Processing_mmsyn7ukr.hs b/Processing_mmsyn7ukr.hs
--- a/Processing_mmsyn7ukr.hs
+++ b/Processing_mmsyn7ukr.hs
@@ -62,16 +62,14 @@
 -- by the first @String@ parameter). 
 produceSound :: (String, String) -> FilePath -> IO ()
 produceSound (actsctrl, noiseLim) file  = onException (do {
-; let file1 = drop (length file - 5) file 
-      soundUkr = getBFst' ("е", V.fromList . zip ["A.wav", "B.wav", "C.wav", "D.wav", "E.wav", "F.wav", "G.wav", "H.wav", 
-        "I.wav", "J.wav", "K.wav", "L.wav", "M.wav", "N.wav", "O.wav", "P.wav", "Q.wav", "R.wav", 
-          "S.wav", "T.wav", "U.wav", "V.wav", "W.wav", "X.wav", "Y.wav", "Z.wav", "a.wav", "b.wav", "c.wav", 
-            "d.wav", "e.wav", "f.wav"] $ ["а", "б", "в", "г", "д", "дж", "дз", "е", "ж", "з", "и", "й", "к", "л", "м", "н", "о", "п", "р", 
-               "с", "сь", "т", "у", "ф", "х", "ц", "ць", "ч", "ш", "ь", "і", "ґ"]) file1
 ; playA file
 ; putStrLn "    *****"
 ; putStrLn "The sound duration is: "
-; produceSound2 (file, file1) (actsctrl, noiseLim) soundUkr
+; produceSound2 (file, drop (length file - 5) file) (actsctrl, noiseLim) . getBFst' ("е", V.fromList . zip ["A.wav", "B.wav", "C.wav", "D.wav", 
+    "E.wav", "F.wav", "G.wav", "H.wav", "I.wav", "J.wav", "K.wav", "L.wav", "M.wav", "N.wav", "O.wav", "P.wav", "Q.wav", "R.wav", "S.wav", 
+       "T.wav", "U.wav", "V.wav", "W.wav", "X.wav", "Y.wav", "Z.wav", "a.wav", "b.wav", "c.wav", "d.wav", "e.wav", "f.wav"] $ 
+          ["а", "б", "в", "г", "д", "дж", "дз", "е", "ж", "з", "и", "й", "к", "л", "м", "н", "о", "п", "р", "с", "сь", "т", "у", "ф", "х", 
+             "ц", "ць", "ч", "ш", "ь", "і", "ґ"]) $ drop (length file - 5) file
 ; return () }) (do
        putStrLn "Something went unexpectedly, please, repeat the procedure again, be attentive to the data you provide as input! "
        putStr "The needed files were NOT created (may be the sound was not at the moment of recording)! The process will be restarted "
@@ -79,54 +77,39 @@
        cleanTemp
        produceSound (actsctrl, noiseLim) file)
 
-
 -- | Function 'produceSound3' is used internally in the 'produceSound2' function.
 produceSound3 :: (String, String) -> (FilePath, FilePath) -> String -> (Int, Double) -> Double -> IO ()
 produceSound3 (actsctrl, noiseLim) (file, file1) soundUkr (noiseMax, duration0) lim0
- | actsctrl == "-1" = do 
-    lim1 <- durationA "8_x.wav"
-    if lim1 <= 0.0
-      then beginProcessing (file, file1) soundUkr (actsctrl, noiseLim)
-      else do 
-        resampleA "8_x.wav" (22050::Int)
-        produceSound4 (file, file1)  "38_x.wav"
- | take 1 actsctrl == "0" = do
-    lim1 <- durationA "8_x.wav"
-    if lim1 <= 0.0
-      then beginProcessing (file, file1) soundUkr (actsctrl, noiseLim)
-      else do 
-        resampleA "8_x.wav" (22050::Int)
-        produceSound4 (file, file1)  "38_x.wav"
+ | actsctrl == "-1" = prodSnd3H (actsctrl, noiseLim) (file, file1) soundUkr
+ | take 1 actsctrl == "0" = prodSnd3H (actsctrl, noiseLim) (file, file1) soundUkr
  | take 1 actsctrl == "1" = do
-    alterVadB "8_x.wav" lim0 noiseMax (duration0*0.03)
+     prodSnd3H2 (actsctrl, noiseLim) (file, file1) soundUkr (noiseMax, duration0) lim0 >>= \lim1 -> 
+       if lim1 <= 0.0 then return () else resampleA "8_x.wav" (22050::Int) >> produceSound4 (file, file1) "38_x.wav"
+ | take 1 actsctrl == "2" = do
+    prodSnd3H2 (actsctrl, noiseLim) (file, file1) soundUkr (noiseMax, duration0) lim0 >>= \lim1 -> 
+     if lim1 <= 0.0 then return () else sincA "8_x.wav" >> resampleA "4.8_x.wav" (22050::Int) >> produceSound4 (file, file1) "34.8_x.wav"
+ | otherwise = do
+    prodSnd3H2 (actsctrl, noiseLim) (file, file1) soundUkr (noiseMax, duration0) lim0 >>= \lim1 -> 
+     if lim1 <= 0.0 then return () else sincA "8_x.wav" >> resampleA "4.8_x.wav" (22050::Int) >> quarterSinFade "34.8_x.wav" >> 
+       produceSound4 (file, file1) "434.8_x.wav"
+
+prodSnd3H :: (String, String) -> (FilePath, FilePath) -> String -> IO ()
+prodSnd3H (actsctrl, noiseLim) (file, file1) soundUkr = do 
     lim1 <- durationA "8_x.wav"
     if lim1 <= 0.0
       then beginProcessing (file, file1) soundUkr (actsctrl, noiseLim)
       else do 
-        alterVadE "8_x.wav" lim1 noiseMax (duration0*0.03)
         resampleA "8_x.wav" (22050::Int)
         produceSound4 (file, file1)  "38_x.wav"
- | take 1 actsctrl == "2" = do
-    alterVadB "8_x.wav" lim0 noiseMax (duration0*0.03)
-    lim1 <- durationA "8_x.wav"
-    if lim1 <= 0.0
-      then beginProcessing (file, file1) soundUkr (actsctrl, noiseLim)
-      else do 
-        alterVadE "8_x.wav" lim1 noiseMax (duration0*0.03)
-        sincA "8_x.wav"
-        resampleA "4.8_x.wav" (22050::Int)
-        produceSound4 (file, file1) "34.8_x.wav"
- | otherwise = do
+
+prodSnd3H2 :: (String, String) -> (FilePath, FilePath) -> String -> (Int, Double) ->  Double -> IO Double
+prodSnd3H2 (actsctrl, noiseLim) (file, file1) soundUkr (noiseMax, duration0) lim0 = do
     alterVadB "8_x.wav" lim0 noiseMax (duration0*0.03)
     lim1 <- durationA "8_x.wav"
     if lim1 <= 0.0
       then beginProcessing (file, file1) soundUkr (actsctrl, noiseLim)
-      else do 
-        alterVadE "8_x.wav" lim1 noiseMax (duration0*0.03)
-        sincA "8_x.wav"
-        resampleA "4.8_x.wav" (22050::Int)
-        quarterSinFade "34.8_x.wav"
-        produceSound4 (file, file1) "434.8_x.wav"
+      else alterVadE "8_x.wav" lim1 noiseMax (duration0*0.03)
+    return lim1
 
 -- | Function 'produceSound4' is used internally in the 'produceSound3' function for amplification 
 -- up/down to the maximum level of the first @FilePath@ parameter in the tuple. The second one gives 
@@ -138,49 +121,11 @@
   volS2 ("8" ++ fileB) file
   renameFile ("8." ++ fileB) file1
 
--- | Function 'produceSound2' is used internally in the 'produceSound' function.
-produceSound2 :: (FilePath, FilePath) -> (String, String) -> String -> IO ()
-produceSound2 (file, file1) (actsctrl, noiseLim) soundUkr = 
- do { duration0 <- durationA file 
-    ; (_, Just hout, _, _) <- createProcess (proc (fromJust . showE $ "soxi") ["-D", file]) { std_out = CreatePipe }
-    ; x3 <- hGetContents hout
-    ; putStrLn $ showCoef (showFFloat (Just 6) duration0 $ show 0)
-    ; putStrLn ""
-    ; putStrLn "It means that to produce more than 3 seconds of recording, you must specify at least "
-    ; putStrLn $ "       " ++ show (3.0/duration0) ++ " as a next step ratio being prompt "
-    ; putStrLn "       OR "
-    ; putStrLn $ "       " ++ show (1.0/duration0) ++ " per one second but not less than the previous number."
-    ; putStrLn $ "For example for 10 seconds record, please, specify " ++ show (10.0/duration0) ++ " as a next step ratio."
-    ; putStrLn "    *****"
-    ; putStrLn ""
-    ; recommendSharp soundUkr
-    ; (longerK0,pause0,sharp) <- tempS soundUkr noiseLim
-    ; let longerK = (read x3::Double)*longerK0
-    ; putStrLn $ "Please, wait for " ++ show pause0 ++ " seconds and pronounce the sound representation for the "
-    ; putStrLn ""
-    ; putStrLn $ "                                   \"" ++ (if soundUkr /= "ь" then map toUpper soundUkr else soundUkr) ++ "\""
-    ; putStrLn ""
-    ; putStrLn " sound or whatever you would like to be substituted instead (be sensible, please)! "
-    ; if sharp || (compare longerK 3.0 == GT)
-         then recB "x.wav" (longerK, pause0)
-         else recB "x.wav" (3.0, pause0)
-    ; putStrLn "The file is recorded and now will be automatically processed. You will be notificated with the text message in the terminal about the creation of the needed file. Please, wait a little. "
-    ; controlNoiseReduction actsctrl
-    ; norm "_x.wav"
-    ; lim0 <- durationA "8_x.wav"
-    ; let end2 = if null noiseLim then "" else [last noiseLim]
-    ; case end2 of
-        "s" -> putStr ""
-        "l" -> printGenInfo1
-        _   -> printGenInfo1
-    ; let noiseMax = getBFst' (2::Int, V.fromList [("0", 0::Int), ("1", 1::Int), ("2", 2::Int), ("3", 3::Int)]) (take 1 noiseLim)
-    ; produceSound3 (actsctrl, noiseLim) (file, file1) soundUkr (noiseMax, duration0) lim0
-    ; cleanTemp }
-
 -- | Function 'showCoef' is used to represent the duration of the sound file.
 showCoef :: String -> String
 showCoef xs | '.' `elem` xs = 
-  let (ts, us) = break (== '.') xs in let ws = showFFloat (Just 6) ((fromIntegral (read (take 6 . drop 1 $ us)::Int) + 1.0) / 1000000.0) $ show 0 in let result = ts ++ drop 1 ws in result
+  let (ts, us) = break (== '.') xs in let ws = showFFloat (Just 6) ((fromIntegral (read (take 6 . drop 1 $ us)::Int) + 1.0) / 1000000.0) "" in 
+    ts ++ drop 1 ws
             | otherwise = xs
       
 -- | Function 'beginProcessing' is used to catch the variant where the sound is fully cut by the SoX because the sound was created in inappropriate time.
@@ -197,8 +142,13 @@
 ; putStrLn "    *****"
 ; putStrLn ""
 ; putStrLn "The sound duration is: "
+; produceSound2 (file, file1) (actsctrl, noiseLim) soundUkr}
+
+-- | Function 'produceSound2' is used internally in the 'produceSound' function.
+produceSound2 :: (FilePath, FilePath) -> (String, String) -> String -> IO ()
+produceSound2 (file, file1) (actsctrl, noiseLim) soundUkr = do {
 ; duration0 <- durationA file
-; putStrLn $ showCoef (showFFloat (Just 6) duration0 $ show 0)
+; putStrLn $ showCoef (showFFloat (Just 6) duration0 "")
 ; putStrLn ""
 ; putStrLn "It means that to produce more than 3 seconds of recording, you must specify at least "
 ; putStrLn $ "   " ++ show (3.0/duration0) ++ " as a next step ratio being prompt "
@@ -223,7 +173,7 @@
 ; putStrLn "The file is recorded and now will be automatically processed. You will be notificated with the text message in the terminal about the creation of the needed file. Please, wait a little. "
 ; controlNoiseReduction actsctrl
 ; norm "_x.wav"
-; lim0 <- durationA "8_x.wav"
+; lim0 <- durationA "8_x.wav" 
 ; if null noiseLim
     then printGenInfo1
     else if last noiseLim == 's'
@@ -384,13 +334,13 @@
 cleanTemp :: IO ()
 cleanTemp = do
   filenames <- getDirectoryContents =<< getCurrentDirectory
-  let rems = filter (\x -> head x `elem` (['2'..'9'] ++ "_" ++ "x")) filenames in mapM_ removeFile rems
+  mapM_ removeFile . filter (\x -> head x `elem` (['2'..'9'] ++ "_" ++ "x")) $ filenames
 
 -- | Function 'cleanTempN' removes all the intermediate temporary files produced during a noise profile creation in the directory where it is called from.
 cleanTempN :: IO ()
 cleanTempN = do
   filenames <- getDirectoryContents =<< getCurrentDirectory
-  let rems = filter (\x -> head x == 'n') filenames in mapM_ removeFile rems
+  mapM_ removeFile . filter (\x -> head x == 'n') $ filenames
 
 -- | Function 'tempeRa' is used to create a noise profile for all the recorded sounds. The function is used internally in the @mmsyn7ukr@
 -- program. While running if you provide a 5 seconds silence as needed, the program @mmsyn7ukr@ will
@@ -402,41 +352,11 @@
     ; putStr "Otherwise, the program can remove from the recorded sound data some important parts as a noise. "
     ; if n == 1 then putStrLn "If you would like not to reduce the noise at all, then, please, specify as the first command line argument \"-1\". "
       else putStr ""
-    ; recA "nx1.wav" 0.07
-    ; threadDelay 100000
-    ; recA "nx2.wav" 0.07
-    ; threadDelay 150000
-    ; recA "nx3.wav" 0.07
-    ; threadDelay 100000
-    ; recA "nx4.wav" 0.07
-    ; threadDelay 100000
-    ; recA "nx5.wav" 0.07
-    ; threadDelay 150000
-    ; upperB1 <- upperBnd "nx1.wav"
-    ; upperB2 <- upperBnd "nx2.wav"
-    ; upperB3 <- upperBnd "nx3.wav"
-    ; upperB4 <- upperBnd "nx4.wav"
-    ; upperB5 <- upperBnd "nx5.wav"    
-    ; (ampl1,_) <- selMaxAbs "nx1.wav" (0,upperB1)
-    ; (ampl2,_) <- selMaxAbs "nx2.wav" (0,upperB2)
-    ; (ampl3,_) <- selMaxAbs "nx3.wav" (0,upperB3)
-    ; (ampl4,_) <- selMaxAbs "nx4.wav" (0,upperB4)
-    ; (ampl5,_) <- selMaxAbs "nx5.wav" (0,upperB5)        
-    ; let b1 = abs (read ampl1::Double)
-          b2 = abs (read ampl2::Double)
-          b3 = abs (read ampl3::Double)
-          b4 = abs (read ampl4::Double)
-          b5 = abs (read ampl5::Double)
-    ; case minimum [b1,b2,b3,b4,b5] of
-        b1 -> renameFile "nx1.wav" "nx0.wav"
-        b2 -> renameFile "nx2.wav" "nx0.wav"
-        b3 -> renameFile "nx3.wav" "nx0.wav"
-        b4 -> renameFile "nx4.wav" "nx0.wav"
-        _  -> renameFile "nx5.wav" "nx0.wav"
-    ; noiseProfB "nx0.wav"
-    ; putStrLn ""
-    ; threadDelay 400000
-    ; putStrLn "The noise sound profile is now created. The program can proceed further." }
+    ; V.imapM_ (\i x -> recA ("nx" ++ show (i + 1) ++ ".wav") 0.07 >> threadDelay (50000 * x)) . V.fromList $ [2,3,2,2,3]
+    ; [upperB1,upperB2,upperB3,upperB4,upperB5] <- mapM (\c -> upperBnd ("nx" ++ (c:".wav"))) "12345"
+    ; v0 <- V.imapM (\i upp -> fmap fst . selMaxAbs ("nx" ++ show (i + 1) ++ ".wav") $ (0,upp)) . V.fromList $ [upperB1,upperB2,upperB3,upperB4,upperB5]
+    ; renameFile ("nx" ++ (show ((V.minIndex . V.map (\x -> abs (read x::Double)) $ v0) + 1) ++ ".wav")) "nx0.wav"
+    ; noiseProfB "nx0.wav" >> putStrLn "" >> threadDelay 400000 >> putStrLn "The noise sound profile is now created. The program can proceed further." }
 
 -- | Function 'recommendSharp' is used to print an advice about the speech transformation for the Ukrainian sounds that you can pronounce
 -- properly continually and so it can be better to use for their producing a \'sharp\' mode.
@@ -614,4 +534,4 @@
   putStr "the program will possibly (in some cases surely) cycle. In such a case,"
   putStrLn "you can terminate it in a usual way by sending interruption signals."
   putStrLn ""
-  
+
diff --git a/SoXBasics1.hs b/SoXBasics1.hs
--- a/SoXBasics1.hs
+++ b/SoXBasics1.hs
@@ -430,3 +430,4 @@
             renameFile ("4." ++ file) file
           else catchEnd (InitialFileNotChanged file)
   else catchEnd ExecutableNotProperlyInstalled
+
diff --git a/mmsyn7ukr.cabal b/mmsyn7ukr.cabal
--- a/mmsyn7ukr.cabal
+++ b/mmsyn7ukr.cabal
@@ -2,7 +2,7 @@
 -- documentation, see http://haskell.org/cabal/users-guide/
 
 name:                mmsyn7ukr
-version:             0.15.4.0
+version:             0.15.5.0
 synopsis:            A simple basic interface to some SoX functionality or to produce a voice that can be used by mmsyn7h
 description:         A program and a library that can be used as a simple basic interface to some SoX functionality or to produce your voice in Ukrainian (if you pronounce the sounds properly) represented by the separate sounds or something special like soft sign.
 homepage:            https://hackage.haskell.org/package/mmsyn7ukr