-- |
-- 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
  [[Char]]
arggs <- IO [[Char]]
getArgs
  let arg1 :: [Char]
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]
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]
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 :: [[Char]]
argss = Int -> [[Char]] -> [[Char]]
forall a. Int -> [a] -> [a]
drop Int
1 [[Char]]
arggs
  Bool
exist2 <- [Char] -> IO Bool
doesFileExist [Char]
file
  IO () -> [([Char], IO ())] -> [Char] -> IO ()
forall a b. Ord a => b -> [(a, b)] -> a -> b
getBFstLSorted' (Bool -> [Char] -> [Char] -> IO ()
dobutokO2H Bool
exist2 [Char]
args [Char]
file) ((([Char], Bool -> [Char] -> [Char] -> IO ()) -> ([Char], IO ()))
-> [([Char], Bool -> [Char] -> [Char] -> IO ())]
-> [([Char], IO ())]
forall a b. (a -> b) -> [a] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\([Char]
xs, Bool -> [Char] -> [Char] -> IO ()
f) -> ([Char]
xs,Bool -> [Char] -> [Char] -> IO ()
f Bool
exist2 [Char]
args [Char]
file)) ([([Char], Bool -> [Char] -> [Char] -> IO ())]
 -> [([Char], IO ())])
-> [([Char], Bool -> [Char] -> [Char] -> IO ())]
-> [([Char], IO ())]
forall a b. (a -> b) -> a -> b
$ [([Char]
"0",Bool -> [Char] -> [Char] -> IO ()
o2help),([Char]
"00",Bool -> [Char] -> [Char] -> IO ()
dobutokO2H00),
    ([Char]
"002",Bool -> [Char] -> [Char] -> IO ()
dobutokO2H002),([Char]
"1",Bool -> [Char] -> [Char] -> IO ()
dobutokO2H1),([Char]
"11",Bool -> [Char] -> [Char] -> IO ()
dobutokO2H11),([Char]
"2",Bool -> [Char] -> [Char] -> IO ()
dobutokO2H2),([Char]
"21",Bool -> [Char] -> [Char] -> IO ()
dobutokO2H21),([Char]
"3",Bool -> [Char] -> [Char] -> IO ()
dobutokO2H3),([Char]
"31",Bool -> [Char] -> [Char] -> IO ()
dobutokO2H31),
      ([Char]
"4",Bool -> [Char] -> [Char] -> IO ()
dobutokO2H4),([Char]
"41",Bool -> [Char] -> [Char] -> IO ()
dobutokO2H41),([Char]
"5",Bool -> [Char] -> [Char] -> IO ()
dobutokO2H5),([Char]
"51",Bool -> [Char] -> [Char] -> IO ()
dobutokO2H51),([Char]
"61",Bool -> [Char] -> [Char] -> IO ()
dobutokO2H61),([Char]
"7",Bool -> [Char] -> [Char] -> IO ()
dobutokO2H7),([Char]
"8",Bool -> [Char] -> [Char] -> IO ()
dobutokO2H8),
        ([Char]
"80",Bool -> [Char] -> [Char] -> IO ()
dobutokO2H80),([Char]
"82",Bool -> [Char] -> [Char] -> IO ()
dobutokO2H82),([Char]
"820",Bool -> [Char] -> [Char] -> IO ()
dobutokO2H820),([Char]
"9",Bool -> [Char] -> [Char] -> IO ()
dobutokO2H9),([Char]
"92",Bool -> [Char] -> [Char] -> IO ()
dobutokO2H92),([Char]
"99",[[Char]] -> Bool -> [Char] -> [Char] -> IO ()
dobutokO2H99 [[Char]]
argss),
          ([Char]
"992",[[Char]] -> Bool -> [Char] -> [Char] -> IO ()
dobutokO2H992G [[Char]]
argss),([Char]
"999",[[Char]] -> Bool -> [Char] -> [Char] -> IO ()
dobutokO2H999 [[Char]]
argss),([Char]
"9992",[[Char]] -> Bool -> [Char] -> [Char] -> IO ()
dobutokO2H9992G [[Char]]
argss)]) [Char]
arg1

dobutokO2H1 :: Bool -> String -> FilePath -> IO ()
dobutokO2H1 :: Bool -> [Char] -> [Char] -> IO ()
dobutokO2H1 Bool
exist2 [Char]
args [Char]
file = do
  [[Char]
_,[Char]
_,[Char]
octave,[Char]
ampLS,[Char]
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 (Int
octave1,Float
ampL,Float
time3) = Maybe (Int, Float, Float) -> (Int, Float, Float)
forall a. HasCallStack => Maybe a -> a
fromJust (Maybe (Int, Float, Float) -> (Int, Float, Float))
-> ([[Char]] -> Maybe (Int, Float, Float))
-> [[Char]]
-> (Int, Float, Float)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [[Char]] -> Maybe (Int, Float, Float)
threeStr2Val ([[Char]] -> (Int, Float, Float))
-> [[Char]] -> (Int, Float, Float)
forall a b. (a -> b) -> a -> b
$ [[Char]
octave,[Char]
ampLS,[Char]
time2] in [Char] -> Int -> Float -> Float -> [Char] -> IO ()
overSoXSynthNGen [Char]
file Int
octave1 Float
ampL Float
time3 [Char]
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
  [[Char]
_,[Char]
_,[Char]
octave,[Char]
ampLS,[Char]
time2,[Char]
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 (Int
octave1,Float
ampL,Float
time3) = Maybe (Int, Float, Float) -> (Int, Float, Float)
forall a. HasCallStack => Maybe a -> a
fromJust (Maybe (Int, Float, Float) -> (Int, Float, Float))
-> ([[Char]] -> Maybe (Int, Float, Float))
-> [[Char]]
-> (Int, Float, Float)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [[Char]] -> Maybe (Int, Float, Float)
threeStr2Val ([[Char]] -> (Int, Float, Float))
-> [[Char]] -> (Int, Float, Float)
forall a b. (a -> b) -> a -> b
$ [[Char]
octave,[Char]
ampLS,[Char]
time2] in [Char] -> Int -> Float -> Float -> [Char] -> [Char] -> IO ()
uniqOverSoXSynthNGen [Char]
file Int
octave1 Float
ampL Float
time3 [Char]
args [Char]
wws
{-# INLINE dobutokO2H2 #-}

dobutokO2H3 :: Bool -> String -> FilePath -> IO ()
dobutokO2H3 :: Bool -> [Char] -> [Char] -> IO ()
dobutokO2H3 Bool
exist2 [Char]
args [Char]
file = do
  [[Char]
_,[Char]
_,[Char]
octave,[Char]
ampLS,[Char]
time2,[Char]
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 (Int
octave1,Float
ampL,Float
time3) = Maybe (Int, Float, Float) -> (Int, Float, Float)
forall a. HasCallStack => Maybe a -> a
fromJust (Maybe (Int, Float, Float) -> (Int, Float, Float))
-> ([[Char]] -> Maybe (Int, Float, Float))
-> [[Char]]
-> (Int, Float, Float)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [[Char]] -> Maybe (Int, Float, Float)
threeStr2Val ([[Char]] -> (Int, Float, Float))
-> [[Char]] -> (Int, Float, Float)
forall a b. (a -> b) -> a -> b
$ [[Char]
octave,[Char]
ampLS,[Char]
time2] in [Char] -> Int -> Float -> Float -> [Char] -> [Char] -> IO ()
overSoXSynthNGen2 [Char]
file Int
octave1 Float
ampL Float
time3 [Char]
args [Char]
tts
{-# INLINE dobutokO2H3 #-}

dobutokO2H4 :: Bool -> String -> FilePath -> IO ()
dobutokO2H4 :: Bool -> [Char] -> [Char] -> IO ()
dobutokO2H4 Bool
exist2 [Char]
args [Char]
file = do
  [[Char]
_,[Char]
_,[Char]
octave,[Char]
ampLS,[Char]
time2,[Char]
wws,[Char]
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 (Int
octave1,Float
ampL,Float
time3) = Maybe (Int, Float, Float) -> (Int, Float, Float)
forall a. HasCallStack => Maybe a -> a
fromJust (Maybe (Int, Float, Float) -> (Int, Float, Float))
-> ([[Char]] -> Maybe (Int, Float, Float))
-> [[Char]]
-> (Int, Float, Float)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [[Char]] -> Maybe (Int, Float, Float)
threeStr2Val ([[Char]] -> (Int, Float, Float))
-> [[Char]] -> (Int, Float, Float)
forall a b. (a -> b) -> a -> b
$ [[Char]
octave,[Char]
ampLS,[Char]
time2] in [Char]
-> Int -> Float -> Float -> [Char] -> [Char] -> [Char] -> IO ()
uniqOverSoXSynthNGen3 [Char]
file Int
octave1 Float
ampL Float
time3 [Char]
args [Char]
wws [Char]
tts
{-# INLINE dobutokO2H4 #-}

dobutokO2H5 :: Bool -> String -> FilePath -> IO ()
dobutokO2H5 :: Bool -> [Char] -> [Char] -> IO ()
dobutokO2H5 Bool
exist2 [Char]
args [Char]
file = do
  [[Char]
_,[Char]
_,[Char]
octave,[Char]
ampLS,[Char]
time2,[Char]
tts,[Char]
dAmpl0,[Char]
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 (Int
octave1,Float
ampL,Float
time3,Float
dAmpl) = Maybe (Int, Float, Float, Float) -> (Int, Float, Float, Float)
forall a. HasCallStack => Maybe a -> a
fromJust (Maybe (Int, Float, Float, Float) -> (Int, Float, Float, Float))
-> ([[Char]] -> Maybe (Int, Float, Float, Float))
-> [[Char]]
-> (Int, Float, Float, Float)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [[Char]] -> Maybe (Int, Float, Float, Float)
fourStr2Val ([[Char]] -> (Int, Float, Float, Float))
-> [[Char]] -> (Int, Float, Float, Float)
forall a b. (a -> b) -> a -> b
$ [[Char]
octave,[Char]
ampLS,[Char]
time2,[Char]
dAmpl0] in [Char]
-> Int
-> Float
-> Float
-> Float
-> [Char]
-> [Char]
-> [Char]
-> IO ()
overSoXSynthNGen3 [Char]
file Int
octave1 Float
ampL Float
time3 Float
dAmpl [Char]
args [Char]
tts [Char]
vs
{-# INLINE dobutokO2H5 #-}

dobutokO2H :: Bool -> String -> FilePath -> IO ()
dobutokO2H :: Bool -> [Char] -> [Char] -> IO ()
dobutokO2H Bool
exist2 [Char]
args [Char]
file = do
  [[Char]
_,[Char]
_,[Char]
octave,[Char]
ampLS,[Char]
time2,[Char]
wws,[Char]
tts,[Char]
dAmpl0,[Char]
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 (Int
octave1,Float
ampL,Float
time3,Float
dAmpl) = Maybe (Int, Float, Float, Float) -> (Int, Float, Float, Float)
forall a. HasCallStack => Maybe a -> a
fromJust (Maybe (Int, Float, Float, Float) -> (Int, Float, Float, Float))
-> ([[Char]] -> Maybe (Int, Float, Float, Float))
-> [[Char]]
-> (Int, Float, Float, Float)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [[Char]] -> Maybe (Int, Float, Float, Float)
fourStr2Val ([[Char]] -> (Int, Float, Float, Float))
-> [[Char]] -> (Int, Float, Float, Float)
forall a b. (a -> b) -> a -> b
$ [[Char]
octave,[Char]
ampLS,[Char]
time2,[Char]
dAmpl0] in
    [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]
tts [Char]
vs
{-# INLINE dobutokO2H #-}

dobutokO2H61 :: Bool -> String -> FilePath -> IO ()
dobutokO2H61 :: Bool -> [Char] -> [Char] -> IO ()
dobutokO2H61 Bool
exist2 [Char]
args [Char]
file = do
  [[Char]
_,[Char]
_,[Char]
complexNky,[Char]
ampLS,[Char]
time2,[Char]
wws,[Char]
tts,[Char]
dAmpl0,[Char]
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 ([Int
enkA,Int
nTh],Float
ampL,Float
time3,Float
dAmpl) = Maybe ([Int], Float, Float, Float) -> ([Int], Float, Float, Float)
forall a. HasCallStack => Maybe a -> a
fromJust (Maybe ([Int], Float, Float, Float)
 -> ([Int], Float, Float, Float))
-> ([[Char]] -> Maybe ([Int], Float, Float, Float))
-> [[Char]]
-> ([Int], Float, Float, Float)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [[Char]] -> Maybe ([Int], Float, Float, Float)
fiveStr2Val ([[Char]] -> ([Int], Float, Float, Float))
-> [[Char]] -> ([Int], Float, Float, Float)
forall a b. (a -> b) -> a -> b
$ [[Char]
complexNky,[Char]
ampLS,[Char]
time2,[Char]
dAmpl0] in
    [Char]
-> Int
-> Int
-> Float
-> Float
-> Float
-> [Char]
-> [Char]
-> [Char]
-> [Char]
-> IO ()
uniqOverSoXSynthNGen4E [Char]
file Int
nTh Int
enkA Float
ampL Float
time3 Float
dAmpl [Char]
args [Char]
wws [Char]
tts [Char]
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
  [[Char]]
path8s0 <- [Char] -> IO [[Char]]
listDirectory [Char]
"."
  let path8v :: Vector [Char]
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 :: Vector (Vector [Char])
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 
  (Int -> Vector [Char] -> IO ()) -> Vector (Vector [Char]) -> IO ()
forall (m :: * -> *) a b.
Monad m =>
(Int -> a -> m b) -> Vector a -> m ()
V.imapM_ Int -> Vector [Char] -> IO ()
dO2H8 Vector (Vector [Char])
path8v1
  [[Char]]
epath0s <- [Char] -> IO [[Char]]
listDirectory [Char]
"."
  let epaths :: [[Char]]
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
  (ExitCode
code1,[Char]
_,[Char]
_) <- [Char] -> [[Char]] -> [Char] -> IO (ExitCode, [Char], [Char])
readProcessWithExitCode (Maybe [Char] -> [Char]
forall a. HasCallStack => Maybe a -> a
fromJust ([Char] -> Maybe [Char]
showE [Char]
"sox")) ([[Char]]
epaths [[Char]] -> [[Char]] -> [[Char]]
forall a. [a] -> [a] -> [a]
++ [[Char]
"end.wav"]) [Char]
""
  case ExitCode
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
      Bool
exi1 <- [Char] -> IO Bool
doesFileExist [Char]
"end.wav"
      if Bool
exi1
        then do
          [Char] -> IO ()
removeFile [Char]
"end.wav"
          [Char] -> IO ()
forall a. HasCallStack => [Char] -> a
error [Char]
"The end file \"end.wav\" was not created. "
        else [Char] -> IO ()
forall a. HasCallStack => [Char] -> a
error [Char]
"The end file \"end.wav\" was not created. "
  (ExitCode, Vector [Char]) -> IO (ExitCode, Vector [Char])
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (ExitCode
code1, Vector [Char]
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
  [[Char]]
path8s0 <- [Char] -> IO [[Char]]
listDirectory [Char]
"."
  let path8v :: Vector [Char]
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 :: Vector (Vector [Char])
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 Int -> [Char] -> [Char]
forall a. Int -> [a] -> [a]
drop Int
3 [Char]
ys [Char] -> [Char] -> Bool
forall a. Eq a => a -> a -> Bool
== [Char]
"f" then (Int -> Vector [Char] -> IO ()) -> Vector (Vector [Char]) -> IO ()
forall (m :: * -> *) a b.
Monad m =>
(Int -> a -> m b) -> Vector a -> m ()
V.imapM_ Int -> Vector [Char] -> IO ()
dO2H8f Vector (Vector [Char])
path8v1 else (Int -> Vector [Char] -> IO ()) -> Vector (Vector [Char]) -> IO ()
forall (m :: * -> *) a b.
Monad m =>
(Int -> a -> m b) -> Vector a -> m ()
V.imapM_ Int -> Vector [Char] -> IO ()
dO2H8 Vector (Vector [Char])
path8v1
  [[Char]]
epath0s <- [Char] -> IO [[Char]]
listDirectory [Char]
"."
  let epaths :: [[Char]]
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
  (ExitCode
code1,[Char]
_,[Char]
_) <- [Char] -> [[Char]] -> [Char] -> IO (ExitCode, [Char], [Char])
readProcessWithExitCode (Maybe [Char] -> [Char]
forall a. HasCallStack => Maybe a -> a
fromJust ([Char] -> Maybe [Char]
showE [Char]
"sox")) ([[Char]]
epaths [[Char]] -> [[Char]] -> [[Char]]
forall a. [a] -> [a] -> [a]
++ [Char] -> [[Char]] -> [[Char]]
soxBasicParams [Char]
ys ([Char]
""[Char] -> [[Char]] -> [[Char]]
forall a. a -> [a] -> [a]
:[[Char]
"end.wav"])) [Char]
""
  case ExitCode
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
      Bool
exiW <- [Char] -> IO Bool
doesFileExist [Char]
"end.wav"
      Bool
exiF <- [Char] -> IO Bool
doesFileExist [Char]
"end.flac"
      if Bool
exiW Bool -> Bool -> Bool
&& Bool -> Bool
not (Bool
exiF)
        then do
          [Char] -> IO ()
removeFile [Char]
"end.wav"
          [Char] -> IO ()
forall a. HasCallStack => [Char] -> a
error [Char]
"The end file \"end.wav\" was not created. "
        else
          if Bool
exiF Bool -> Bool -> Bool
&& Bool -> Bool
not (Bool
exiW) then do
            [Char] -> IO ()
removeFile [Char]
"end.flac"
            [Char] -> IO ()
forall a. HasCallStack => [Char] -> a
error [Char]
"The end file \"end.flac\" was not created. "
          else if Bool
exiF Bool -> Bool -> Bool
&& Bool
exiW then do
                 [Char] -> IO ()
removeFile [Char]
"end.flac"
                 [Char] -> IO ()
removeFile [Char]
"end.wav"
                 [Char] -> IO ()
forall a. HasCallStack => [Char] -> a
error [Char]
"The end file \"end.*\" was not created. "
               else [Char] -> IO ()
forall a. HasCallStack => [Char] -> a
error [Char]
"The end file \"end.*\" was not created. "
  (ExitCode, Vector [Char]) -> IO (ExitCode, Vector [Char])
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (ExitCode
code1, Vector [Char]
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
  [[Char]
_,[Char]
_,[Char]
complexNky,[Char]
ampLS,[Char]
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 ([Int
enkA,Int
nTh],Float
ampL,Float
time3,Float
_) = Maybe ([Int], Float, Float, Float) -> ([Int], Float, Float, Float)
forall a. HasCallStack => Maybe a -> a
fromJust (Maybe ([Int], Float, Float, Float)
 -> ([Int], Float, Float, Float))
-> ([[Char]] -> Maybe ([Int], Float, Float, Float))
-> [[Char]]
-> ([Int], Float, Float, Float)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [[Char]] -> Maybe ([Int], Float, Float, Float)
fiveStr2Val ([[Char]] -> ([Int], Float, Float, Float))
-> [[Char]] -> ([Int], Float, Float, Float)
forall a b. (a -> b) -> a -> b
$ [[Char]
complexNky,[Char]
ampLS,[Char]
time2,[Char]
""] in [Char] -> Int -> Int -> Float -> Float -> [Char] -> IO ()
overSoXSynthNGenE [Char]
file Int
nTh Int
enkA Float
ampL Float
time3 [Char]
args
{-# INLINE dobutokO2H11 #-}

dobutokO2H21 :: Bool -> String -> FilePath -> IO ()
dobutokO2H21 :: Bool -> [Char] -> [Char] -> IO ()
dobutokO2H21 Bool
exist2 [Char]
args [Char]
file = do
  [[Char]
_,[Char]
_,[Char]
complexNky,[Char]
ampLS,[Char]
time2,[Char]
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 ([Int
enkA,Int
nTh],Float
ampL,Float
time3,Float
_) = Maybe ([Int], Float, Float, Float) -> ([Int], Float, Float, Float)
forall a. HasCallStack => Maybe a -> a
fromJust (Maybe ([Int], Float, Float, Float)
 -> ([Int], Float, Float, Float))
-> ([[Char]] -> Maybe ([Int], Float, Float, Float))
-> [[Char]]
-> ([Int], Float, Float, Float)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [[Char]] -> Maybe ([Int], Float, Float, Float)
fiveStr2Val ([[Char]] -> ([Int], Float, Float, Float))
-> [[Char]] -> ([Int], Float, Float, Float)
forall a b. (a -> b) -> a -> b
$ [[Char]
complexNky,[Char]
ampLS,[Char]
time2,[Char]
""] in [Char] -> Int -> Int -> Float -> Float -> [Char] -> [Char] -> IO ()
uniqOverSoXSynthNGenE [Char]
file Int
nTh Int
enkA Float
ampL Float
time3 [Char]
args [Char]
wws
{-# INLINE dobutokO2H21 #-}

dobutokO2H31 :: Bool -> String -> FilePath -> IO ()
dobutokO2H31 :: Bool -> [Char] -> [Char] -> IO ()
dobutokO2H31 Bool
exist2 [Char]
args [Char]
file = do
  [[Char]
_,[Char]
_,[Char]
complexNky,[Char]
ampLS,[Char]
time2,[Char]
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 ([Int
enkA,Int
nTh],Float
ampL,Float
time3,Float
_) = Maybe ([Int], Float, Float, Float) -> ([Int], Float, Float, Float)
forall a. HasCallStack => Maybe a -> a
fromJust (Maybe ([Int], Float, Float, Float)
 -> ([Int], Float, Float, Float))
-> ([[Char]] -> Maybe ([Int], Float, Float, Float))
-> [[Char]]
-> ([Int], Float, Float, Float)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [[Char]] -> Maybe ([Int], Float, Float, Float)
fiveStr2Val ([[Char]] -> ([Int], Float, Float, Float))
-> [[Char]] -> ([Int], Float, Float, Float)
forall a b. (a -> b) -> a -> b
$ [[Char]
complexNky,[Char]
ampLS,[Char]
time2,[Char]
""] in [Char] -> Int -> Int -> Float -> Float -> [Char] -> [Char] -> IO ()
overSoXSynthNGen2E [Char]
file Int
nTh Int
enkA Float
ampL Float
time3 [Char]
args [Char]
tts
{-# INLINE dobutokO2H31 #-}

dobutokO2H41 :: Bool -> String -> FilePath -> IO ()
dobutokO2H41 :: Bool -> [Char] -> [Char] -> IO ()
dobutokO2H41 Bool
exist2 [Char]
args [Char]
file = do
  [[Char]
_,[Char]
_,[Char]
complexNky,[Char]
ampLS,[Char]
time2,[Char]
wws,[Char]
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 ([Int
enkA,Int
nTh],Float
ampL,Float
time3,Float
_) = Maybe ([Int], Float, Float, Float) -> ([Int], Float, Float, Float)
forall a. HasCallStack => Maybe a -> a
fromJust (Maybe ([Int], Float, Float, Float)
 -> ([Int], Float, Float, Float))
-> ([[Char]] -> Maybe ([Int], Float, Float, Float))
-> [[Char]]
-> ([Int], Float, Float, Float)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [[Char]] -> Maybe ([Int], Float, Float, Float)
fiveStr2Val ([[Char]] -> ([Int], Float, Float, Float))
-> [[Char]] -> ([Int], Float, Float, Float)
forall a b. (a -> b) -> a -> b
$ [[Char]
complexNky,[Char]
ampLS,[Char]
time2,[Char]
""] in [Char]
-> Int
-> Int
-> Float
-> Float
-> [Char]
-> [Char]
-> [Char]
-> IO ()
uniqOverSoXSynthNGen3E [Char]
file Int
nTh Int
enkA Float
ampL Float
time3 [Char]
args [Char]
wws [Char]
tts
{-# INLINE dobutokO2H41 #-}

dobutokO2H51 :: Bool -> String -> FilePath -> IO ()
dobutokO2H51 :: Bool -> [Char] -> [Char] -> IO ()
dobutokO2H51 Bool
exist2 [Char]
args [Char]
file = do
  [[Char]
_,[Char]
_,[Char]
complexNky,[Char]
ampLS,[Char]
time2,[Char]
tts,[Char]
dAmpl0,[Char]
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 ([Int
enkA,Int
nTh],Float
ampL,Float
time3,Float
dAmpl) = Maybe ([Int], Float, Float, Float) -> ([Int], Float, Float, Float)
forall a. HasCallStack => Maybe a -> a
fromJust (Maybe ([Int], Float, Float, Float)
 -> ([Int], Float, Float, Float))
-> ([[Char]] -> Maybe ([Int], Float, Float, Float))
-> [[Char]]
-> ([Int], Float, Float, Float)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [[Char]] -> Maybe ([Int], Float, Float, Float)
fiveStr2Val ([[Char]] -> ([Int], Float, Float, Float))
-> [[Char]] -> ([Int], Float, Float, Float)
forall a b. (a -> b) -> a -> b
$ [[Char]
complexNky,[Char]
ampLS,[Char]
time2,[Char]
dAmpl0] in
    [Char]
-> Int
-> Int
-> Float
-> Float
-> Float
-> [Char]
-> [Char]
-> [Char]
-> IO ()
overSoXSynthNGen3E [Char]
file Int
nTh Int
enkA Float
ampL Float
time3 Float
dAmpl [Char]
args [Char]
tts [Char]
vs
{-# INLINE dobutokO2H51 #-}

dO2H8 :: Int -> V.Vector String -> IO ()
dO2H8 :: Int -> Vector [Char] -> IO ()
dO2H8 Int
i Vector [Char]
v = do
  (ExitCode
code,[Char]
_,[Char]
_) <- [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 ExitCode
code of
    ExitCode
ExitSuccess -> [Char] -> IO ()
putStr [Char]
""
    ExitCode
_           -> do
      Bool
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 Bool
exi0
        then do
          [Char] -> IO ()
removeFile ([Char] -> IO ()) -> [Char] -> IO ()
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"
          [Char] -> IO ()
forall a. HasCallStack => [Char] -> a
error ([Char] -> IO ()) -> [Char] -> IO ()
forall a b. (a -> b) -> a -> b
$ [Char]
"The intermediate file " [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\" was not created. "
        else [Char] -> IO ()
forall a. HasCallStack => [Char] -> a
error ([Char] -> IO ()) -> [Char] -> IO ()
forall a b. (a -> b) -> a -> b
$ [Char]
"The intermediate file " [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\" was not created. "
{-# INLINE dO2H8 #-}

dO2H8f :: Int -> V.Vector String -> IO ()
dO2H8f :: Int -> Vector [Char] -> IO ()
dO2H8f Int
i Vector [Char]
v = do
  (ExitCode
code,[Char]
_,[Char]
_) <- [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 ExitCode
code of
    ExitCode
ExitSuccess -> [Char] -> IO ()
putStr [Char]
""
    ExitCode
_           -> do
      Bool
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 Bool
exi0
        then do
          [Char] -> IO ()
removeFile ([Char] -> IO ()) -> [Char] -> IO ()
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"
          [Char] -> IO ()
forall a. HasCallStack => [Char] -> a
error ([Char] -> IO ()) -> [Char] -> IO ()
forall a b. (a -> b) -> a -> b
$ [Char]
"The intermediate file " [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\" was not created. "
        else [Char] -> IO ()
forall a. HasCallStack => [Char] -> a
error ([Char] -> IO ()) -> [Char] -> IO ()
forall a b. (a -> b) -> a -> b
$ [Char]
"The intermediate file " [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\" 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
  (Vector Int
v1,Vector [Char]
dir0V) <- [Char] -> [Char] -> IO (Vector Int, Vector [Char])
dO2H99 [Char]
"221w" [Char]
file 
  (Int -> IO ()) -> Vector Int -> IO ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> Vector a -> m ()
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) Vector Int
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
  Vector [Char]
dir0V <- [Char] -> IO (Vector [Char])
listVDirectory2G [Char]
ys
  let l0 :: Int
l0 = Vector [Char] -> Int
forall a. Vector a -> Int
V.length Vector [Char]
dir0V
  [Char] -> IO ()
putStrLn ([Char] -> IO ()) -> [Char] -> IO ()
forall a b. (a -> b) -> a -> b
$ [Char]
"You have available " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ Int -> [Char]
forall a. Show a => a -> [Char]
show Int
l0 [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
" files that can be played. The minimum index further is 0, the maximum is " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ Int -> [Char]
forall a. Show a => a -> [Char]
show (Int
l0 Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1)
  [Char]
list1 <- [Char] -> Int -> IO [Char]
recAndProcess [Char]
file (Int
99::Int)
  let yss :: [[Int]]
yss = Int -> [Char] -> [[Int]]
divideToStr Int
l0 [Char]
list1
      v01 :: Vector [Int]
v01 = [[Int]] -> Vector [Int]
forall a. [a] -> Vector a
V.fromList [[Int]]
yss
      mxE :: Int
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
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]]
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 :: Vector Int
v1 = [[Int]] -> Vector Int
forall a. Ord a => [[a]] -> Vector a
doubleLtoV [[Int]]
zss
  (Vector Int, Vector [Char]) -> IO (Vector Int, Vector [Char])
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Vector Int
v1,Vector [Char]
dir0V)
{-# INLINE dO2H99 #-}

dobutokO2H992G :: [String] -> Bool -> String -> FilePath -> IO ()
dobutokO2H992G :: [[Char]] -> Bool -> [Char] -> [Char] -> IO ()
dobutokO2H992G [[Char]]
argss Bool
_ [Char]
ys [Char]
file = do
  (Vector Int
v1,Vector [Char]
dir0V) <- [Char] -> [Char] -> IO (Vector Int, Vector [Char])
dO2H99 [Char]
ys [Char]
file 
  (Int -> IO ()) -> Vector Int -> IO ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> Vector a -> m ()
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) Vector Int
v1
{-# INLINE dobutokO2H992G #-}

dobutokO2H999 :: [String] -> Bool -> String -> FilePath -> IO ()
dobutokO2H999 :: [[Char]] -> Bool -> [Char] -> [Char] -> IO ()
dobutokO2H999 [[Char]]
argss Bool
_ [Char]
_ [Char]
file = do
  (Vector Int
v1,Vector [Char]
dir0V) <- [Char] -> [Char] -> IO (Vector Int, Vector [Char])
dO2H99 [Char]
"221w" [Char]
file 
  (Int -> IO ()) -> Vector Int -> IO ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> Vector a -> m ()
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) Vector Int
v1
{-# INLINE dobutokO2H999 #-}

dobutokO2H9992G :: [String] -> Bool -> String -> FilePath -> IO ()
dobutokO2H9992G :: [[Char]] -> Bool -> [Char] -> [Char] -> IO ()
dobutokO2H9992G [[Char]]
argss Bool
_ [Char]
ys [Char]
file = do
  (Vector Int
v1,Vector [Char]
dir0V) <- [Char] -> [Char] -> IO (Vector Int, Vector [Char])
dO2H99 [Char]
ys [Char]
file 
  (Int -> IO ()) -> Vector Int -> IO ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> Vector a -> m ()
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) Vector Int
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). "
  [Char]
input <- IO [Char]
getContents
  let text0 :: [[Char]]
text0   = [Char] -> [[Char]]
lines [Char]
input
      listTxt :: [[Char]]
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 :: Int
l       = [[Char]] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [[Char]]
listTxt
  case Int
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
  [Char]
_ <- IO [Char]
processD1
  [Char]
_ <- [Char] -> IO [Char]
processD2 [Char]
file
  Bool -> [Char] -> [Char] -> IO ()
dobutokO2H7 Bool
True [Char]
args [Char]
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
  [Char]
xs <- IO [Char]
getContents
  let ys :: [Char]
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
    [Char] -> IO ()
putStrLn [Char]
""
    [Char] -> IO ()
putStrLn [Char]
"-------------------------------------------------------------------------------------------------------------"
    [Char] -> IO ()
putStrLn [Char]
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 #-}