-- |
-- Module      :  DobutokO.Sound.Executable
-- Copyright   :  (c) OleksandrZhabenko 2020, 2024
-- License     :  MIT
-- Stability   :  Experimental
-- Maintainer  :  oleksandr.zhabenko@yahoo.com
--
-- Helps to create experimental music from a file (or its part) and a Ukrainian text. 
-- It can also generate a timbre for the notes. Uses SoX inside.

{-# LANGUAGE LambdaCase #-}
{-# OPTIONS_GHC -threaded #-}

module DobutokO.Sound.Executable (
  -- * Basic functions for the executable
  dobutokO2
  , dobutokO2H7
  , dobutokO2H9
  , dobutokO2H92
  , o2help
) where

import Control.Monad (void)
import System.Exit (ExitCode (ExitSuccess))
import qualified Data.List as L (groupBy,sort)
import CaseBi.Arr (getBFstLSorted')
import Control.Exception (onException)
import System.Environment (getArgs)
import Data.List (isPrefixOf)
import Data.Maybe (fromJust,fromMaybe)
import System.Process
import EndOfExe2 (showE)
import qualified Data.Vector as V (Vector,generate,fromList,length,imapM_,snoc,toList,unsafeSlice,mapM_,unsafeIndex)
import System.Directory
import DobutokO.Sound.Overtones
import DobutokO.Sound.Uniq
import DobutokO.Sound.IntermediateF 
import DobutokO.Sound.ParseList (parseStoLInts)
import DobutokO.Sound.Process

-- | Function that actually makes processing in the @dobutokO2@ executable. Please, check before executing
-- whether there is no \"x.wav\", \"test*\", \"result*\" and \"end*\" files in the current directory, because they can be overwritten.
dobutokO2 :: IO ()
dobutokO2 :: IO ()
dobutokO2 = do
  arggs <- IO [[Char]]
getArgs
  let arg1 = [[Char]] -> [Char]
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat ([[Char]] -> [Char])
-> ([[Char]] -> [[Char]]) -> [[Char]] -> [Char]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> [[Char]] -> [[Char]]
forall a. Int -> [a] -> [a]
take Int
1 ([[Char]] -> [Char]) -> [[Char]] -> [Char]
forall a b. (a -> b) -> a -> b
$ [[Char]]
arggs
      file = [[Char]] -> [Char]
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat ([[Char]] -> [Char])
-> ([[Char]] -> [[Char]]) -> [[Char]] -> [Char]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> [[Char]] -> [[Char]]
forall a. Int -> [a] -> [a]
drop Int
1 ([[Char]] -> [[Char]])
-> ([[Char]] -> [[Char]]) -> [[Char]] -> [[Char]]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> [[Char]] -> [[Char]]
forall a. Int -> [a] -> [a]
take Int
2 ([[Char]] -> [Char]) -> [[Char]] -> [Char]
forall a b. (a -> b) -> a -> b
$ [[Char]]
arggs
      args = [[Char]] -> [Char]
unwords ([[Char]] -> [Char])
-> ([[Char]] -> [[Char]]) -> [[Char]] -> [Char]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> [[Char]] -> [[Char]]
forall a. Int -> [a] -> [a]
drop Int
2 ([[Char]] -> [Char]) -> [[Char]] -> [Char]
forall a b. (a -> b) -> a -> b
$ [[Char]]
arggs
      argss = Int -> [[Char]] -> [[Char]]
forall a. Int -> [a] -> [a]
drop Int
1 [[Char]]
arggs
  exist2 <- doesFileExist file
  getBFstLSorted' (dobutokO2H exist2 args file) (fmap (\([Char]
xs, Bool -> [Char] -> [Char] -> IO ()
f) -> ([Char]
xs,Bool -> [Char] -> [Char] -> IO ()
f Bool
exist2 [Char]
args [Char]
file)) $ [("0",o2help),("00",dobutokO2H00),
    ("002",dobutokO2H002),("1",dobutokO2H1),("11",dobutokO2H11),("2",dobutokO2H2),("21",dobutokO2H21),("3",dobutokO2H3),("31",dobutokO2H31),
      ("4",dobutokO2H4),("41",dobutokO2H41),("5",dobutokO2H5),("51",dobutokO2H51),("61",dobutokO2H61),("7",dobutokO2H7),("8",dobutokO2H8),
        ("80",dobutokO2H80),("82",dobutokO2H82),("820",dobutokO2H820),("9",dobutokO2H9),("92",dobutokO2H92),("99",dobutokO2H99 argss),
          ("992",dobutokO2H992G argss),("999",dobutokO2H999 argss),("9992",dobutokO2H9992G argss)]) arg1

dobutokO2H1 :: Bool -> String -> FilePath -> IO ()
dobutokO2H1 :: Bool -> [Char] -> [Char] -> IO ()
dobutokO2H1 Bool
exist2 [Char]
args [Char]
file = do
  [_,_,octave,ampLS,time2] <- (Int -> IO [Char]) -> [Int] -> IO [[Char]]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM ([Char] -> Int -> IO [Char]
recAndProcess [Char]
file) (if Bool
exist2 then [Int
0,Int
2,Int
3,Int
4,Int
5] else [Int
1..Int
5])
  let (octave1,ampL,time3) = fromJust . threeStr2Val $ [octave,ampLS,time2] in overSoXSynthNGen file octave1 ampL time3 args
{-# INLINE dobutokO2H1 #-}

threeStr2Val :: [String] -> Maybe (Int,Float,Float)
threeStr2Val :: [[Char]] -> Maybe (Int, Float, Float)
threeStr2Val [[Char]
xs,[Char]
ys,[Char]
zs] = (Int, Float, Float) -> Maybe (Int, Float, Float)
forall a. a -> Maybe a
Just ([Char] -> Int
forall a. Read a => [Char] -> a
read [Char]
xs::Int,[Char] -> Float
forall a. Read a => [Char] -> a
read [Char]
ys::Float,[Char] -> Float
forall a. Read a => [Char] -> a
read [Char]
zs::Float)
threeStr2Val [[Char]]
_ = Maybe (Int, Float, Float)
forall a. Maybe a
Nothing
{-# INLINE threeStr2Val #-}

fourStr2Val :: [String] -> Maybe (Int,Float,Float,Float)
fourStr2Val :: [[Char]] -> Maybe (Int, Float, Float, Float)
fourStr2Val [[Char]
xs,[Char]
ys,[Char]
zs,[Char]
tws] = (Int, Float, Float, Float) -> Maybe (Int, Float, Float, Float)
forall a. a -> Maybe a
Just ([Char] -> Int
forall a. Read a => [Char] -> a
read [Char]
xs::Int,[Char] -> Float
forall a. Read a => [Char] -> a
read [Char]
ys::Float,[Char] -> Float
forall a. Read a => [Char] -> a
read [Char]
zs::Float,[Char] -> Float
forall a. Read a => [Char] -> a
read [Char]
tws::Float)
fourStr2Val [[Char]]
_ = Maybe (Int, Float, Float, Float)
forall a. Maybe a
Nothing
{-# INLINE fourStr2Val #-}

fiveStr2Val :: [String] -> Maybe ([Int],Float,Float,Float)
fiveStr2Val :: [[Char]] -> Maybe ([Int], Float, Float, Float)
fiveStr2Val [[Char]
xs,[Char]
ys,[Char]
zs,[Char]
tws] = ([Int], Float, Float, Float) -> Maybe ([Int], Float, Float, Float)
forall a. a -> Maybe a
Just (([Char] -> Int) -> [[Char]] -> [Int]
forall a b. (a -> b) -> [a] -> [b]
map (\[Char]
z -> [Char] -> Int
forall a. Read a => [Char] -> a
read [Char]
z::Int) ([[Char]] -> [Int]) -> ([Char] -> [[Char]]) -> [Char] -> [Int]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Char] -> [[Char]]
words ([Char] -> [Int]) -> [Char] -> [Int]
forall a b. (a -> b) -> a -> b
$ [Char]
xs,[Char] -> Float
forall a. Read a => [Char] -> a
read [Char]
ys::Float,[Char] -> Float
forall a. Read a => [Char] -> a
read [Char]
zs::Float,[Char] -> Float
forall a. Read a => [Char] -> a
read [Char]
tws::Float)
fiveStr2Val [[Char]]
_ = Maybe ([Int], Float, Float, Float)
forall a. Maybe a
Nothing
{-# INLINE fiveStr2Val #-}

dobutokO2H2 :: Bool -> String -> FilePath -> IO ()
dobutokO2H2 :: Bool -> [Char] -> [Char] -> IO ()
dobutokO2H2 Bool
exist2 [Char]
args [Char]
file = do
  [_,_,octave,ampLS,time2,wws] <- (Int -> IO [Char]) -> [Int] -> IO [[Char]]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM ([Char] -> Int -> IO [Char]
recAndProcess [Char]
file) (if Bool
exist2 then [Int
0,Int
2,Int
3,Int
4,Int
5,Int
6] else [Int
1..Int
6])
  let (octave1,ampL,time3) = fromJust . threeStr2Val $ [octave,ampLS,time2] in uniqOverSoXSynthNGen file octave1 ampL time3 args wws
{-# INLINE dobutokO2H2 #-}

dobutokO2H3 :: Bool -> String -> FilePath -> IO ()
dobutokO2H3 :: Bool -> [Char] -> [Char] -> IO ()
dobutokO2H3 Bool
exist2 [Char]
args [Char]
file = do
  [_,_,octave,ampLS,time2,tts] <- (Int -> IO [Char]) -> [Int] -> IO [[Char]]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM ([Char] -> Int -> IO [Char]
recAndProcess [Char]
file) (if Bool
exist2 then [Int
0,Int
2,Int
3,Int
4,Int
5,Int
7] else [Int
1,Int
2,Int
3,Int
4,Int
5,Int
7])
  let (octave1,ampL,time3) = fromJust . threeStr2Val $ [octave,ampLS,time2] in overSoXSynthNGen2 file octave1 ampL time3 args tts
{-# INLINE dobutokO2H3 #-}

dobutokO2H4 :: Bool -> String -> FilePath -> IO ()
dobutokO2H4 :: Bool -> [Char] -> [Char] -> IO ()
dobutokO2H4 Bool
exist2 [Char]
args [Char]
file = do
  [_,_,octave,ampLS,time2,wws,tts] <- (Int -> IO [Char]) -> [Int] -> IO [[Char]]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM ([Char] -> Int -> IO [Char]
recAndProcess [Char]
file) (if Bool
exist2 then [Int
0,Int
2,Int
3,Int
4,Int
5,Int
6,Int
7] else [Int
1..Int
7])
  let (octave1,ampL,time3) = fromJust . threeStr2Val $ [octave,ampLS,time2] in uniqOverSoXSynthNGen3 file octave1 ampL time3 args wws tts
{-# INLINE dobutokO2H4 #-}

dobutokO2H5 :: Bool -> String -> FilePath -> IO ()
dobutokO2H5 :: Bool -> [Char] -> [Char] -> IO ()
dobutokO2H5 Bool
exist2 [Char]
args [Char]
file = do
  [_,_,octave,ampLS,time2,tts,dAmpl0,vs] <- (Int -> IO [Char]) -> [Int] -> IO [[Char]]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM ([Char] -> Int -> IO [Char]
recAndProcess [Char]
file) (if Bool
exist2 then [Int
0,Int
2,Int
3,Int
4,Int
5,Int
7,Int
8,Int
9] else [Int
1,Int
2,Int
3,Int
4,Int
5,Int
7,Int
8,Int
9])
  let (octave1,ampL,time3,dAmpl) = fromJust . fourStr2Val $ [octave,ampLS,time2,dAmpl0] in overSoXSynthNGen3 file octave1 ampL time3 dAmpl args tts vs
{-# INLINE dobutokO2H5 #-}

dobutokO2H :: Bool -> String -> FilePath -> IO ()
dobutokO2H :: Bool -> [Char] -> [Char] -> IO ()
dobutokO2H Bool
exist2 [Char]
args [Char]
file = do
  [_,_,octave,ampLS,time2,wws,tts,dAmpl0,vs] <- (Int -> IO [Char]) -> [Int] -> IO [[Char]]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM ([Char] -> Int -> IO [Char]
recAndProcess [Char]
file) (if Bool
exist2 then [Int
0,Int
2,Int
3,Int
4,Int
5,Int
6,Int
7,Int
8,Int
9] else [Int
1..Int
9])
  let (octave1,ampL,time3,dAmpl) = fromJust . fourStr2Val $ [octave,ampLS,time2,dAmpl0] in
    uniqOverSoXSynthNGen4 file octave1 ampL time3 dAmpl args wws tts vs
{-# INLINE dobutokO2H #-}

dobutokO2H61 :: Bool -> String -> FilePath -> IO ()
dobutokO2H61 :: Bool -> [Char] -> [Char] -> IO ()
dobutokO2H61 Bool
exist2 [Char]
args [Char]
file = do
  [_,_,complexNky,ampLS,time2,wws,tts,dAmpl0,vs] <- (Int -> IO [Char]) -> [Int] -> IO [[Char]]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM ([Char] -> Int -> IO [Char]
recAndProcess [Char]
file) (if Bool
exist2 then [Int
0,Int
2,Int
11,Int
4,Int
5,Int
6,Int
7,Int
8,Int
9] else [Int
1,Int
2,Int
11,Int
4,Int
5,Int
6,Int
7,Int
8,Int
9])
  let ([enkA,nTh],ampL,time3,dAmpl) = fromJust . fiveStr2Val $ [complexNky,ampLS,time2,dAmpl0] in
    uniqOverSoXSynthNGen4E file nTh enkA ampL time3 dAmpl args wws tts vs
{-# INLINE dobutokO2H61 #-}

dobutokO2H8 :: Bool -> String -> FilePath -> IO ()
dobutokO2H8 :: Bool -> [Char] -> [Char] -> IO ()
dobutokO2H8 Bool
exist2 [Char]
args [Char]
file = IO (ExitCode, Vector [Char]) -> IO ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (Bool -> [Char] -> [Char] -> IO (ExitCode, Vector [Char])
dobutokO2H8G Bool
exist2 [Char]
args [Char]
file)
{-# INLINE dobutokO2H8 #-}

dobutokO2H80 :: Bool -> String -> FilePath -> IO ()
dobutokO2H80 :: Bool -> [Char] -> [Char] -> IO ()
dobutokO2H80 Bool
exist2 [Char]
args [Char]
file = Bool -> [Char] -> [Char] -> IO (ExitCode, Vector [Char])
dobutokO2H8G Bool
exist2 [Char]
args [Char]
file  IO (ExitCode, Vector [Char])
-> ((ExitCode, Vector [Char]) -> IO ()) -> IO ()
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \case
    (ExitCode
ExitSuccess, Vector [Char]
path8v) -> ([Char] -> IO ()) -> Vector [Char] -> IO ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> Vector a -> m ()
V.mapM_ [Char] -> IO ()
removeFile Vector [Char]
path8v
    (ExitCode, Vector [Char])
_           -> () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
{-# INLINE dobutokO2H80 #-}

dobutokO2H8G :: Bool -> String -> FilePath -> IO (ExitCode, V.Vector FilePath)
dobutokO2H8G :: Bool -> [Char] -> [Char] -> IO (ExitCode, Vector [Char])
dobutokO2H8G Bool
_ [Char]
_ [Char]
_ = do
  path8s0 <- [Char] -> IO [[Char]]
listDirectory [Char]
"."
  let path8v = [[Char]] -> Vector [Char]
forall a. [a] -> Vector a
V.fromList ([[Char]] -> Vector [Char])
-> ([[Char]] -> [[Char]]) -> [[Char]] -> Vector [Char]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [[Char]] -> [[Char]]
forall a. Ord a => [a] -> [a]
L.sort ([[Char]] -> [[Char]])
-> ([[Char]] -> [[Char]]) -> [[Char]] -> [[Char]]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ([Char] -> Bool) -> [[Char]] -> [[Char]]
forall a. (a -> Bool) -> [a] -> [a]
filter ([Char] -> [Char] -> Bool
forall a. Eq a => [a] -> [a] -> Bool
isPrefixOf [Char]
"result") ([[Char]] -> Vector [Char]) -> [[Char]] -> Vector [Char]
forall a b. (a -> b) -> a -> b
$ [[Char]]
path8s0
      path8v1 = Int -> (Int -> Vector [Char]) -> Vector (Vector [Char])
forall a. Int -> (Int -> a) -> Vector a
V.generate (Vector [Char] -> Int
forall a. Vector a -> Int
V.length Vector [Char]
path8v Int -> Int -> Int
forall a. Integral a => a -> a -> a
`quot` Int
800) (\Int
i0 -> Int -> Int -> Vector [Char] -> Vector [Char]
forall a. Int -> Int -> Vector a -> Vector a
V.unsafeSlice (Int
i0 Int -> Int -> Int
forall a. Num a => a -> a -> a
* Int
800) Int
800 Vector [Char]
path8v ) Vector (Vector [Char]) -> Vector [Char] -> Vector (Vector [Char])
forall a. Vector a -> a -> Vector a
`V.snoc` Int -> Int -> Vector [Char] -> Vector [Char]
forall a. Int -> Int -> Vector a -> Vector a
V.unsafeSlice (Int
800 Int -> Int -> Int
forall a. Num a => a -> a -> a
*
         (Vector [Char] -> Int
forall a. Vector a -> Int
V.length Vector [Char]
path8v Int -> Int -> Int
forall a. Integral a => a -> a -> a
`quot` Int
800)) (Vector [Char] -> Int
forall a. Vector a -> Int
V.length Vector [Char]
path8v Int -> Int -> Int
forall a. Integral a => a -> a -> a
`rem` Int
800) Vector [Char]
path8v 
  V.imapM_ dO2H8 path8v1
  epath0s <- listDirectory "."
  let epaths = [[Char]] -> [[Char]]
forall a. Ord a => [a] -> [a]
L.sort ([[Char]] -> [[Char]])
-> ([[Char]] -> [[Char]]) -> [[Char]] -> [[Char]]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ([Char] -> Bool) -> [[Char]] -> [[Char]]
forall a. (a -> Bool) -> [a] -> [a]
filter ([Char] -> [Char] -> Bool
forall a. Eq a => [a] -> [a] -> Bool
isPrefixOf [Char]
"end0") ([[Char]] -> [[Char]]) -> [[Char]] -> [[Char]]
forall a b. (a -> b) -> a -> b
$ [[Char]]
epath0s
  (code1,_,_) <- readProcessWithExitCode (fromJust (showE "sox")) (epaths ++ ["end.wav"]) ""
  case code1 of
    ExitCode
ExitSuccess -> ([Char] -> IO ()) -> [[Char]] -> IO ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ [Char] -> IO ()
removeFile [[Char]]
epaths
    ExitCode
_           -> do
      exi1 <- [Char] -> IO Bool
doesFileExist [Char]
"end.wav"
      if exi1
        then do
          removeFile "end.wav"
          error "The end file \"end.wav\" was not created. "
        else error "The end file \"end.wav\" was not created. "
  return (code1, path8v)
{-# INLINE dobutokO2H8G #-}

dobutokO2H82G :: Bool -> String -> FilePath -> IO (ExitCode, V.Vector FilePath)
dobutokO2H82G :: Bool -> [Char] -> [Char] -> IO (ExitCode, Vector [Char])
dobutokO2H82G Bool
_ [Char]
ys [Char]
_ = do
  path8s0 <- [Char] -> IO [[Char]]
listDirectory [Char]
"."
  let path8v = [[Char]] -> Vector [Char]
forall a. [a] -> Vector a
V.fromList ([[Char]] -> Vector [Char])
-> ([[Char]] -> [[Char]]) -> [[Char]] -> Vector [Char]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [[Char]] -> [[Char]]
forall a. Ord a => [a] -> [a]
L.sort ([[Char]] -> [[Char]])
-> ([[Char]] -> [[Char]]) -> [[Char]] -> [[Char]]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ([Char] -> Bool) -> [[Char]] -> [[Char]]
forall a. (a -> Bool) -> [a] -> [a]
filter ([Char] -> [Char] -> Bool
forall a. Eq a => [a] -> [a] -> Bool
isPrefixOf [Char]
"result") ([[Char]] -> Vector [Char]) -> [[Char]] -> Vector [Char]
forall a b. (a -> b) -> a -> b
$ [[Char]]
path8s0
      path8v1 = Int -> (Int -> Vector [Char]) -> Vector (Vector [Char])
forall a. Int -> (Int -> a) -> Vector a
V.generate (Vector [Char] -> Int
forall a. Vector a -> Int
V.length Vector [Char]
path8v Int -> Int -> Int
forall a. Integral a => a -> a -> a
`quot` Int
800) (\Int
i0 -> Int -> Int -> Vector [Char] -> Vector [Char]
forall a. Int -> Int -> Vector a -> Vector a
V.unsafeSlice (Int
i0 Int -> Int -> Int
forall a. Num a => a -> a -> a
* Int
800) Int
800 Vector [Char]
path8v ) Vector (Vector [Char]) -> Vector [Char] -> Vector (Vector [Char])
forall a. Vector a -> a -> Vector a
`V.snoc` Int -> Int -> Vector [Char] -> Vector [Char]
forall a. Int -> Int -> Vector a -> Vector a
V.unsafeSlice (Int
800 Int -> Int -> Int
forall a. Num a => a -> a -> a
*
         (Vector [Char] -> Int
forall a. Vector a -> Int
V.length Vector [Char]
path8v Int -> Int -> Int
forall a. Integral a => a -> a -> a
`quot` Int
800)) (Vector [Char] -> Int
forall a. Vector a -> Int
V.length Vector [Char]
path8v Int -> Int -> Int
forall a. Integral a => a -> a -> a
`rem` Int
800) Vector [Char]
path8v 
  if drop 3 ys == "f" then V.imapM_ dO2H8f path8v1 else V.imapM_ dO2H8 path8v1
  epath0s <- listDirectory "."
  let epaths = [[Char]] -> [[Char]]
forall a. Ord a => [a] -> [a]
L.sort ([[Char]] -> [[Char]])
-> ([[Char]] -> [[Char]]) -> [[Char]] -> [[Char]]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ([Char] -> Bool) -> [[Char]] -> [[Char]]
forall a. (a -> Bool) -> [a] -> [a]
filter ([Char] -> [Char] -> Bool
forall a. Eq a => [a] -> [a] -> Bool
isPrefixOf [Char]
"end0") ([[Char]] -> [[Char]]) -> [[Char]] -> [[Char]]
forall a b. (a -> b) -> a -> b
$ [[Char]]
epath0s
  (code1,_,_) <- readProcessWithExitCode (fromJust (showE "sox")) (epaths ++ soxBasicParams ys ("":["end.wav"])) ""
  case code1 of
    ExitCode
ExitSuccess -> ([Char] -> IO ()) -> [[Char]] -> IO ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ [Char] -> IO ()
removeFile [[Char]]
epaths
    ExitCode
_           -> do
      exiW <- [Char] -> IO Bool
doesFileExist [Char]
"end.wav"
      exiF <- doesFileExist "end.flac"
      if exiW && not (exiF)
        then do
          removeFile "end.wav"
          error "The end file \"end.wav\" was not created. "
        else
          if exiF && not (exiW) then do
            removeFile "end.flac"
            error "The end file \"end.flac\" was not created. "
          else if exiF && exiW then do
                 removeFile "end.flac"
                 removeFile "end.wav"
                 error "The end file \"end.*\" was not created. "
               else error "The end file \"end.*\" was not created. "
  return (code1, path8v)
{-# INLINE dobutokO2H82G #-}

dobutokO2H82 :: Bool -> String -> FilePath -> IO ()
dobutokO2H82 :: Bool -> [Char] -> [Char] -> IO ()
dobutokO2H82 Bool
exist2 [Char]
ys [Char]
file = IO (ExitCode, Vector [Char]) -> IO ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (Bool -> [Char] -> [Char] -> IO (ExitCode, Vector [Char])
dobutokO2H82G Bool
exist2 [Char]
ys [Char]
file)
{-# INLINE dobutokO2H82 #-}

dobutokO2H820 :: Bool -> String -> FilePath -> IO ()
dobutokO2H820 :: Bool -> [Char] -> [Char] -> IO ()
dobutokO2H820 Bool
exist2 [Char]
ys [Char]
file = Bool -> [Char] -> [Char] -> IO (ExitCode, Vector [Char])
dobutokO2H82G Bool
exist2 [Char]
ys [Char]
file  IO (ExitCode, Vector [Char])
-> ((ExitCode, Vector [Char]) -> IO ()) -> IO ()
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \case
    (ExitCode
ExitSuccess, Vector [Char]
path8v) -> ([Char] -> IO ()) -> Vector [Char] -> IO ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> Vector a -> m ()
V.mapM_ [Char] -> IO ()
removeFile Vector [Char]
path8v
    (ExitCode, Vector [Char])
_           -> () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
{-# INLINE dobutokO2H820 #-}

dobutokO2H11 :: Bool -> String -> FilePath -> IO ()
dobutokO2H11 :: Bool -> [Char] -> [Char] -> IO ()
dobutokO2H11 Bool
exist2 [Char]
args [Char]
file = do
  [_,_,complexNky,ampLS,time2] <- (Int -> IO [Char]) -> [Int] -> IO [[Char]]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM ([Char] -> Int -> IO [Char]
recAndProcess [Char]
file) (if Bool
exist2 then [Int
0,Int
2,Int
11,Int
4,Int
5] else [Int
1,Int
2,Int
11,Int
4,Int
5])
  let ([enkA,nTh],ampL,time3,_) = fromJust . fiveStr2Val $ [complexNky,ampLS,time2,""] in overSoXSynthNGenE file nTh enkA ampL time3 args
{-# INLINE dobutokO2H11 #-}

dobutokO2H21 :: Bool -> String -> FilePath -> IO ()
dobutokO2H21 :: Bool -> [Char] -> [Char] -> IO ()
dobutokO2H21 Bool
exist2 [Char]
args [Char]
file = do
  [_,_,complexNky,ampLS,time2,wws] <- (Int -> IO [Char]) -> [Int] -> IO [[Char]]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM ([Char] -> Int -> IO [Char]
recAndProcess [Char]
file) (if Bool
exist2 then [Int
0,Int
2,Int
11,Int
4,Int
5,Int
6] else [Int
1,Int
2,Int
11,Int
4,Int
5,Int
6])
  let ([enkA,nTh],ampL,time3,_) = fromJust . fiveStr2Val $ [complexNky,ampLS,time2,""] in uniqOverSoXSynthNGenE file nTh enkA ampL time3 args wws
{-# INLINE dobutokO2H21 #-}

dobutokO2H31 :: Bool -> String -> FilePath -> IO ()
dobutokO2H31 :: Bool -> [Char] -> [Char] -> IO ()
dobutokO2H31 Bool
exist2 [Char]
args [Char]
file = do
  [_,_,complexNky,ampLS,time2,tts] <- (Int -> IO [Char]) -> [Int] -> IO [[Char]]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM ([Char] -> Int -> IO [Char]
recAndProcess [Char]
file) (if Bool
exist2 then [Int
0,Int
2,Int
11,Int
4,Int
5,Int
7] else [Int
1,Int
2,Int
11,Int
4,Int
5,Int
7])
  let ([enkA,nTh],ampL,time3,_) = fromJust . fiveStr2Val $ [complexNky,ampLS,time2,""] in overSoXSynthNGen2E file nTh enkA ampL time3 args tts
{-# INLINE dobutokO2H31 #-}

dobutokO2H41 :: Bool -> String -> FilePath -> IO ()
dobutokO2H41 :: Bool -> [Char] -> [Char] -> IO ()
dobutokO2H41 Bool
exist2 [Char]
args [Char]
file = do
  [_,_,complexNky,ampLS,time2,wws,tts] <- (Int -> IO [Char]) -> [Int] -> IO [[Char]]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM ([Char] -> Int -> IO [Char]
recAndProcess [Char]
file) (if Bool
exist2 then [Int
0,Int
2,Int
11,Int
4,Int
5,Int
6,Int
7] else [Int
1,Int
2,Int
11,Int
4,Int
5,Int
6,Int
7])
  let ([enkA,nTh],ampL,time3,_) = fromJust . fiveStr2Val $ [complexNky,ampLS,time2,""] in uniqOverSoXSynthNGen3E file nTh enkA ampL time3 args wws tts
{-# INLINE dobutokO2H41 #-}

dobutokO2H51 :: Bool -> String -> FilePath -> IO ()
dobutokO2H51 :: Bool -> [Char] -> [Char] -> IO ()
dobutokO2H51 Bool
exist2 [Char]
args [Char]
file = do
  [_,_,complexNky,ampLS,time2,tts,dAmpl0,vs] <- (Int -> IO [Char]) -> [Int] -> IO [[Char]]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM ([Char] -> Int -> IO [Char]
recAndProcess [Char]
file) (if Bool
exist2 then [Int
0,Int
2,Int
11,Int
4,Int
5,Int
7,Int
8,Int
9] else [Int
1,Int
2,Int
11,Int
4,Int
5,Int
7,Int
8,Int
9])
  let ([enkA,nTh],ampL,time3,dAmpl) = fromJust . fiveStr2Val $ [complexNky,ampLS,time2,dAmpl0] in
    overSoXSynthNGen3E file nTh enkA ampL time3 dAmpl args tts vs
{-# INLINE dobutokO2H51 #-}

dO2H8 :: Int -> V.Vector String -> IO ()
dO2H8 :: Int -> Vector [Char] -> IO ()
dO2H8 Int
i Vector [Char]
v = do
  (code,_,_) <- [Char] -> [[Char]] -> [Char] -> IO (ExitCode, [Char], [Char])
readProcessWithExitCode (Maybe [Char] -> [Char]
forall a. HasCallStack => Maybe a -> a
fromJust ([Char] -> Maybe [Char]
showE [Char]
"sox")) (Vector [Char] -> [[Char]]
forall a. Vector a -> [a]
V.toList Vector [Char]
v [[Char]] -> [[Char]] -> [[Char]]
forall a. [a] -> [a] -> [a]
++ [[Char]
"end0" [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ Int -> [Char]
forall a. Show a => a -> [Char]
show Int
i [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
".wav"]) [Char]
""
  case code of
    ExitCode
ExitSuccess -> [Char] -> IO ()
putStr [Char]
""
    ExitCode
_           -> do
      exi0 <- [Char] -> IO Bool
doesFileExist ([Char] -> IO Bool) -> [Char] -> IO Bool
forall a b. (a -> b) -> a -> b
$ [Char]
"end0" [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ Int -> [Char]
forall a. Show a => a -> [Char]
show Int
i [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
".wav"
      if exi0
        then do
          removeFile $ "end0" ++ show i ++ ".wav"
          error $ "The intermediate file " ++ "\"end0" ++ show i ++ ".wav\" was not created. "
        else error $ "The intermediate file " ++ "\"end0" ++ show i ++ ".wav\" was not created. "
{-# INLINE dO2H8 #-}

dO2H8f :: Int -> V.Vector String -> IO ()
dO2H8f :: Int -> Vector [Char] -> IO ()
dO2H8f Int
i Vector [Char]
v = do
  (code,_,_) <- [Char] -> [[Char]] -> [Char] -> IO (ExitCode, [Char], [Char])
readProcessWithExitCode (Maybe [Char] -> [Char]
forall a. HasCallStack => Maybe a -> a
fromJust ([Char] -> Maybe [Char]
showE [Char]
"sox")) (Vector [Char] -> [[Char]]
forall a. Vector a -> [a]
V.toList Vector [Char]
v [[Char]] -> [[Char]] -> [[Char]]
forall a. [a] -> [a] -> [a]
++ [[Char]
"end0" [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ Int -> [Char]
forall a. Show a => a -> [Char]
show Int
i [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
".flac"]) [Char]
""
  case code of
    ExitCode
ExitSuccess -> [Char] -> IO ()
putStr [Char]
""
    ExitCode
_           -> do
      exi0 <- [Char] -> IO Bool
doesFileExist ([Char] -> IO Bool) -> [Char] -> IO Bool
forall a b. (a -> b) -> a -> b
$ [Char]
"end0" [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ Int -> [Char]
forall a. Show a => a -> [Char]
show Int
i [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
".flac"
      if exi0
        then do
          removeFile $ "end0" ++ show i ++ ".flac"
          error $ "The intermediate file " ++ "\"end0" ++ show i ++ ".flac\" was not created. "
        else error $ "The intermediate file " ++ "\"end0" ++ show i ++ ".flac\" was not created. "
{-# INLINE dO2H8f #-}

-- | Actually works as 'pAnR_' function.
dobutokO2H9 :: Bool -> String -> FilePath -> IO ()
dobutokO2H9 :: Bool -> [Char] -> [Char] -> IO ()
dobutokO2H9 Bool
_ [Char]
_ [Char]
_ = IO ()
pAnR_
{-# INLINE dobutokO2H9 #-}

-- | Actually works as 'pAnR_2G' function.
dobutokO2H92 :: Bool -> String -> FilePath -> IO ()
dobutokO2H92 :: Bool -> [Char] -> [Char] -> IO ()
dobutokO2H92 Bool
_ [Char]
ys [Char]
_ = [Char] -> IO ()
pAnR_2G [Char]
ys
{-# INLINE dobutokO2H92 #-}

dobutokO2H99 :: [String] -> Bool -> String -> FilePath -> IO ()
dobutokO2H99 :: [[Char]] -> Bool -> [Char] -> [Char] -> IO ()
dobutokO2H99 [[Char]]
argss Bool
_ [Char]
_ [Char]
file = do
  (v1,dir0V) <- [Char] -> [Char] -> IO (Vector Int, Vector [Char])
dO2H99 [Char]
"221w" [Char]
file 
  V.mapM_ (\Int
idx -> [Char] -> [[Char]] -> IO ()
playE (Vector [Char] -> Int -> [Char]
forall a. Vector a -> Int -> a
V.unsafeIndex Vector [Char]
dir0V Int
idx) [[Char]]
argss) v1
{-# INLINE dobutokO2H99 #-}

dO2H99 :: String -> FilePath -> IO (V.Vector Int,V.Vector FilePath)
dO2H99 :: [Char] -> [Char] -> IO (Vector Int, Vector [Char])
dO2H99 [Char]
ys [Char]
file = do
  dir0V <- [Char] -> IO (Vector [Char])
listVDirectory2G [Char]
ys
  let l0 = Vector [Char] -> Int
forall a. Vector a -> Int
V.length Vector [Char]
dir0V
  putStrLn $ "You have available " ++ show l0 ++ " files that can be played. The minimum index further is 0, the maximum is " ++ show (l0 - 1)
  list1 <- recAndProcess file (99::Int)
  let yss = Int -> [Char] -> [[Int]]
divideToStr Int
l0 [Char]
list1
      v01 = [[Int]] -> Vector [Int]
forall a. [a] -> Vector a
V.fromList [[Int]]
yss
      mxE = Int -> Maybe Int -> Int
forall a. a -> Maybe a -> a
fromMaybe (Int
l0 Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1) (Vector [Int] -> Maybe Int
forall a. Ord a => Vector [a] -> Maybe a
maxLinV Vector [Int]
v01)
      mnE = Int -> Maybe Int -> Int
forall a. a -> Maybe a -> a
fromMaybe Int
0 (Vector [Int] -> Maybe Int
forall a. Ord a => Vector [a] -> Maybe a
minLinV Vector [Int]
v01)
      zss = ([Int] -> [Int]) -> [[Int]] -> [[Int]]
forall a b. (a -> b) -> [a] -> [b]
map (Int -> Int -> [Int] -> [Int]
filterToBnds Int
mnE Int
mxE) [[Int]]
yss
      v1 = [[Int]] -> Vector Int
forall a. Ord a => [[a]] -> Vector a
doubleLtoV [[Int]]
zss
  return (v1,dir0V)
{-# INLINE dO2H99 #-}

dobutokO2H992G :: [String] -> Bool -> String -> FilePath -> IO ()
dobutokO2H992G :: [[Char]] -> Bool -> [Char] -> [Char] -> IO ()
dobutokO2H992G [[Char]]
argss Bool
_ [Char]
ys [Char]
file = do
  (v1,dir0V) <- [Char] -> [Char] -> IO (Vector Int, Vector [Char])
dO2H99 [Char]
ys [Char]
file 
  V.mapM_ (\Int
idx -> [Char] -> [[Char]] -> IO ()
playE (Vector [Char] -> Int -> [Char]
forall a. Vector a -> Int -> a
V.unsafeIndex Vector [Char]
dir0V Int
idx) [[Char]]
argss) v1
{-# INLINE dobutokO2H992G #-}

dobutokO2H999 :: [String] -> Bool -> String -> FilePath -> IO ()
dobutokO2H999 :: [[Char]] -> Bool -> [Char] -> [Char] -> IO ()
dobutokO2H999 [[Char]]
argss Bool
_ [Char]
_ [Char]
file = do
  (v1,dir0V) <- [Char] -> [Char] -> IO (Vector Int, Vector [Char])
dO2H99 [Char]
"221w" [Char]
file 
  V.mapM_ (\Int
idx -> [Char] -> [[Char]] -> IO ()
soxE1 (Vector [Char] -> Int -> [Char]
forall a. Vector a -> Int -> a
V.unsafeIndex Vector [Char]
dir0V Int
idx) [[Char]]
argss) v1
{-# INLINE dobutokO2H999 #-}

dobutokO2H9992G :: [String] -> Bool -> String -> FilePath -> IO ()
dobutokO2H9992G :: [[Char]] -> Bool -> [Char] -> [Char] -> IO ()
dobutokO2H9992G [[Char]]
argss Bool
_ [Char]
ys [Char]
file = do
  (v1,dir0V) <- [Char] -> [Char] -> IO (Vector Int, Vector [Char])
dO2H99 [Char]
ys [Char]
file 
  V.mapM_ (\Int
idx -> [Char] -> [[Char]] -> IO ()
soxE1 (Vector [Char] -> Int -> [Char]
forall a. Vector a -> Int -> a
V.unsafeIndex Vector [Char]
dir0V Int
idx) [[Char]]
argss) v1
{-# INLINE dobutokO2H9992G #-}

divideToStr :: Int -> String -> [[Int]]
divideToStr :: Int -> [Char] -> [[Int]]
divideToStr Int
n = ([Char] -> [Int]) -> [[Char]] -> [[Int]]
forall a b. (a -> b) -> [a] -> [b]
map (Int -> [Char] -> [Int]
parseStoLInts Int
n)([[Char]] -> [[Int]]) -> ([Char] -> [[Char]]) -> [Char] -> [[Int]]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Char] -> [[Char]]
lines

isDataStr :: String -> Bool
isDataStr :: [Char] -> Bool
isDataStr = Char -> [Char] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
notElem Char
'@'

isTextPair :: String -> String -> Bool
isTextPair :: [Char] -> [Char] -> Bool
isTextPair [Char]
xs [Char]
ys = [Char] -> Bool
isDataStr [Char]
xs Bool -> Bool -> Bool
&& [Char] -> Bool
isDataStr [Char]
ys

-- | Used to obtain one multiline specially formatted textual input and do the full processment for the sound. 
-- The function generates overtones using additional 'String' and allows maximum control over the parameters.
-- Besides, all the needed information it obtains from the singular formatted input, which can be ended
-- with a keyboard keys combination that means an end of input (e. g. for Unices, that is probably Ctrl + D).
-- \'@\' are separators for the input parts for their respective parts. For more information about the
-- format of the single input, see:
--
-- 'https://drive.google.com/open?id=10Z_GRZR4TKoL5KXfqPm-t-4humuHN0O4'
--
-- The file is also provided with the package as text.dat.txt. 
-- The last two or three inputs (an input just here means a textual input between two \'@\') can be omitted,
-- the program will work also but with less control for the user possible. 
-- 
dobutokO2H7 :: Bool -> String -> FilePath -> IO ()
dobutokO2H7 :: Bool -> [Char] -> [Char] -> IO ()
dobutokO2H7 Bool
True [Char]
args [Char]
file = do
  [Char] -> IO ()
putStrLn [Char]
"Please, specify a prepared textual input. To end the input press a keyboard keys combination that means an end of the input (e. g. for Unices, possibly Ctrl + D). "
  input <- IO [Char]
getContents
  let text0   = [Char] -> [[Char]]
lines [Char]
input
      listTxt = ([Char] -> Bool) -> [[Char]] -> [[Char]]
forall a. (a -> Bool) -> [a] -> [a]
filter [Char] -> Bool
isDataStr ([[Char]] -> [[Char]])
-> ([[Char]] -> [[Char]]) -> [[Char]] -> [[Char]]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ([[Char]] -> [Char]) -> [[[Char]]] -> [[Char]]
forall a b. (a -> b) -> [a] -> [b]
map ([[Char]] -> [Char]
unwords ([[Char]] -> [Char])
-> ([[Char]] -> [[Char]]) -> [[Char]] -> [Char]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Char] -> [[Char]]
words ([Char] -> [[Char]])
-> ([[Char]] -> [Char]) -> [[Char]] -> [[Char]]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [[Char]] -> [Char]
unlines) ([[[Char]]] -> [[Char]])
-> ([[Char]] -> [[[Char]]]) -> [[Char]] -> [[Char]]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ([Char] -> [Char] -> Bool) -> [[Char]] -> [[[Char]]]
forall a. (a -> a -> Bool) -> [a] -> [[a]]
L.groupBy [Char] -> [Char] -> Bool
isTextPair ([[Char]] -> [[Char]]) -> [[Char]] -> [[Char]]
forall a b. (a -> b) -> a -> b
$ [[Char]]
text0
      l       = [[Char]] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [[Char]]
listTxt
  case l of
    Int
4 -> IO () -> IO () -> IO ()
forall a b. IO a -> IO b -> IO a
onException (do
      let [[Char]
octave0,[Char]
ampLS0,[Char]
time20,[Char]
wws] = [[Char]]
listTxt
          octave1 :: Int
octave1 = [Char] -> Int
forall a. Read a => [Char] -> a
read ([Char] -> [Char]
d3H [Char]
octave0)::Int
          ampL :: Float
ampL = [Char] -> Float
forall a. Read a => [Char] -> a
read ([Char] -> [Char]
d4H [Char]
ampLS0)::Float
          time3 :: Float
time3 = [Char] -> Float
forall a. Read a => [Char] -> a
read ([Char] -> [Char]
d5H [Char]
time20)::Float
      [Char] -> Int -> Float -> Float -> [Char] -> [Char] -> IO ()
uniqOverSoXSynthNGen [Char]
file Int
octave1 Float
ampL Float
time3 [Char]
args [Char]
wws) (do
        [Char] -> IO ()
putStrLn [Char]
"--------------------------------------------------------------------------------------------------------------------"
        [Char] -> IO ()
putStrLn [Char]
""
        [Char] -> IO ()
putStrLn [Char]
"The operation was not successful because of the not valid textual input. Please, specify a valid textual input. "
        Bool -> [Char] -> [Char] -> IO ()
dobutokO2H7 Bool
True [Char]
args [Char]
file)
    Int
5 -> IO () -> IO () -> IO ()
forall a b. IO a -> IO b -> IO a
onException (do
      let [[Char]
octave0,[Char]
ampLS0,[Char]
time20,[Char]
wws,[Char]
tts0] = [[Char]]
listTxt
          octave1 :: Int
octave1 = [Char] -> Int
forall a. Read a => [Char] -> a
read ([Char] -> [Char]
d3H [Char]
octave0)::Int
          ampL :: Float
ampL = [Char] -> Float
forall a. Read a => [Char] -> a
read ([Char] -> [Char]
d4H [Char]
ampLS0)::Float
          time3 :: Float
time3 = [Char] -> Float
forall a. Read a => [Char] -> a
read ([Char] -> [Char]
d5H [Char]
time20)::Float
      [Char]
-> Int -> Float -> Float -> [Char] -> [Char] -> [Char] -> IO ()
uniqOverSoXSynthNGen3 [Char]
file Int
octave1 Float
ampL Float
time3 [Char]
args [Char]
wws ([Char] -> [Char]
d7H [Char]
tts0)) (do
        [Char] -> IO ()
putStrLn [Char]
"--------------------------------------------------------------------------------------------------------------------"
        [Char] -> IO ()
putStrLn [Char]
""
        [Char] -> IO ()
putStrLn [Char]
"The operation was not successful because of the not valid textual input. Please, specify a valid textual input. "
        Bool -> [Char] -> [Char] -> IO ()
dobutokO2H7 Bool
True [Char]
args [Char]
file)
    Int
7 -> IO () -> IO () -> IO ()
forall a b. IO a -> IO b -> IO a
onException (do
      let [[Char]
octave0,[Char]
ampLS0,[Char]
time20,[Char]
wws,[Char]
tts0,[Char]
dAmpl0,[Char]
vs0] = [[Char]]
listTxt
          octave1 :: Int
octave1 = [Char] -> Int
forall a. Read a => [Char] -> a
read ([Char] -> [Char]
d3H [Char]
octave0)::Int
          ampL :: Float
ampL = [Char] -> Float
forall a. Read a => [Char] -> a
read ([Char] -> [Char]
d4H [Char]
ampLS0)::Float
          time3 :: Float
time3 = [Char] -> Float
forall a. Read a => [Char] -> a
read ([Char] -> [Char]
d5H [Char]
time20)::Float
          dAmpl :: Float
dAmpl = [Char] -> Float
forall a. Read a => [Char] -> a
read ([Char] -> [Char]
d8H [Char]
dAmpl0)::Float
      [Char]
-> Int
-> Float
-> Float
-> Float
-> [Char]
-> [Char]
-> [Char]
-> [Char]
-> IO ()
uniqOverSoXSynthNGen4 [Char]
file Int
octave1 Float
ampL Float
time3 Float
dAmpl [Char]
args [Char]
wws ([Char] -> [Char]
d7H [Char]
tts0) ([Char] -> [Char]
d9H [Char]
vs0)) (do
        [Char] -> IO ()
putStrLn [Char]
"--------------------------------------------------------------------------------------------------------------------"
        [Char] -> IO ()
putStrLn [Char]
""
        [Char] -> IO ()
putStrLn [Char]
"The operation was not successful because of the not valid textual input. Please, specify a valid textual input. "
        Bool -> [Char] -> [Char] -> IO ()
dobutokO2H7 Bool
True [Char]
args [Char]
file)
    Int
_ -> do
        [Char] -> IO ()
putStrLn [Char]
"--------------------------------------------------------------------------------------------------------------------"
        [Char] -> IO ()
putStrLn [Char]
""
        [Char] -> IO ()
putStrLn [Char]
"The operation was not successful because of the not valid textual input. Please, specify a valid textual input. "
        Bool -> [Char] -> [Char] -> IO ()
dobutokO2H7 Bool
True [Char]
args [Char]
file
dobutokO2H7 Bool
_ [Char]
args [Char]
file = IO () -> IO () -> IO ()
forall a b. IO a -> IO b -> IO a
onException (do
  _ <- IO [Char]
processD1
  _ <- processD2 file
  dobutokO2H7 True args file) (do
    [Char] -> IO ()
putStrLn [Char]
"--------------------------------------------------------------------------------------------------------------------"
    [Char] -> IO ()
putStrLn [Char]
""
    [Char] -> IO ()
putStr [Char]
"The operation was not successful because the file with such a name does not exist or was not created by a program. "
    [Char] -> IO ()
putStrLn [Char]
"Please, interrupt a program and start again with a better data. "
    Bool -> [Char] -> [Char] -> IO ()
dobutokO2H7 Bool
False [Char]
args [Char]
file)
{-# INLINE dobutokO2H7 #-}

-- | Takes textual input from the stdin and prints it as one 'String' to the stdout.
o2help :: Bool -> String -> FilePath -> IO ()
o2help :: Bool -> [Char] -> [Char] -> IO ()
o2help Bool
_ [Char]
_ [Char]
_ = do
  xs <- IO [Char]
getContents
  let ys = [[Char]] -> [Char]
unwords ([[Char]] -> [Char]) -> ([Char] -> [[Char]]) -> [Char] -> [Char]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Char] -> [[Char]]
lines ([Char] -> [Char]) -> [Char] -> [Char]
forall a b. (a -> b) -> a -> b
$ [Char]
xs in do
    putStrLn ""
    putStrLn "-------------------------------------------------------------------------------------------------------------"
    putStrLn ys

dobutokO2H00 :: Bool -> String -> FilePath -> IO ()
dobutokO2H00 :: Bool -> [Char] -> [Char] -> IO ()
dobutokO2H00 Bool
_ = [Char] -> [Char] -> IO ()
fadeAllE
{-# INLINE dobutokO2H00 #-}

dobutokO2H002 :: Bool -> String -> FilePath -> IO ()
dobutokO2H002 :: Bool -> [Char] -> [Char] -> IO ()
dobutokO2H002 Bool
_ = Int -> [Char] -> [Char] -> IO ()
fadeAllEMilN Int
2
{-# INLINE dobutokO2H002 #-}