{-# LANGUAGE NoImplicitPrelude, BangPatterns #-}

module Phladiprelio.Ukrainian.IO where

import GHC.Base
import GHC.Num (Integer,(+),(-),(*))
import GHC.Real (fromIntegral,(/),quot,rem,quotRem)
import GHC.Enum (fromEnum,toEnum)
import Text.Show (Show(..))
import Text.Read (readMaybe)
import Data.Char (isDigit)
import System.IO (putStrLn, FilePath,stdout,hSetNewlineMode,universalNewlineMode,getLine,appendFile)
import Rhythmicity.MarkerSeqs hiding (id) 
import Data.List hiding (foldr)
import Data.Maybe (isNothing,fromJust) 
import Data.Tuple (fst)
import Phladiprelio.Ukrainian.Syllable 
import Phladiprelio.Ukrainian.SyllableDouble
import Phladiprelio.Ukrainian.Melodics 
import GHC.Int (Int8)
import Phladiprelio.Ukrainian.ReadDurations
import Data.Ord (comparing)
import Numeric (showFFloat)
import Phladiprelio.Halfsplit
import System.Directory (readable,writable,getPermissions,Permissions(..))
import Data.ReversedScientific

generalF :: FilePath -> Int -> HashCorrections -> (Int8,[Int8]) -> Int -> Bool -> Int -> Bool -> Int8 -> (FilePath, Int) -> [String] -> IO [String]
generalF :: String
-> Int
-> HashCorrections
-> (Int8, [Int8])
-> Int
-> Bool
-> Int
-> Bool
-> Int8
-> (String, Int)
-> [String]
-> IO [String]
generalF String
file Int
numTest HashCorrections
hc (Int8
grps,[Int8]
mxms) Int
k Bool
descending Int
hashStep Bool
emptyline Int8
splitting (String
fs,Int
code) universalSet :: [String]
universalSet@(String
u1:String
u2:[String]
us) = do
   [[[[Int8]]] -> [[Double]]]
syllableDurationsDs <- String -> IO [[[[Int8]]] -> [[Double]]]
readSyllableDurations String
file
   let syllN :: Int
syllN = String -> Int
countSyll forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Int -> [a] -> [a]
take Int
1 forall a b. (a -> b) -> a -> b
$ [String]
universalSet
--       universalSet = map unwords . permutations . words $ rs
       f :: [[[[Int8]]] -> [[Double]]] -> Int8 -> [Int8] -> String -> Integer
f [[[[Int8]]] -> [[Double]]]
syllableDurationsDs Int8
grps [Int8]
mxms = forall (t :: * -> *) a. (Foldable t, Num a) => t a -> a
sum forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a.
Ord a =>
Int -> HashCorrections -> Int8 -> [Int8] -> [a] -> [Integer]
countHashes2G Int
hashStep HashCorrections
hc Int8
grps [Int8]
mxms forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Monoid a => [a] -> a
mconcat forall b c a. (b -> c) -> (a -> b) -> a -> c
. 
                (if forall (t :: * -> *) a. Foldable t => t a -> Bool
null String
file then case Int
k of { Int
1 -> [[[Int8]]] -> [[Double]]
syllableDurationsD; Int
2 -> [[[Int8]]] -> [[Double]]
syllableDurationsD2; Int
3 -> [[[Int8]]] -> [[Double]]
syllableDurationsD3; Int
4 -> [[[Int8]]] -> [[Double]]
syllableDurationsD4} 
                         else  if forall (t :: * -> *) a. Foldable t => t a -> Int
length [[[[Int8]]] -> [[Double]]]
syllableDurationsDs forall a. Ord a => a -> a -> Bool
>= Int
k then [[[[Int8]]] -> [[Double]]]
syllableDurationsDs forall a. [a] -> Int -> a
!! (Int
k forall a. Num a => a -> a -> a
- Int
1) else [[[Int8]]] -> [[Double]]
syllableDurationsD2) forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> [[[Int8]]]
createSyllablesUkrS
   Handle -> NewlineMode -> IO ()
hSetNewlineMode Handle
stdout NewlineMode
universalNewlineMode
   if Int
numTest forall a. Ord a => a -> a -> Bool
>= Int
0 Bool -> Bool -> Bool
&& Int
numTest forall a. Ord a => a -> a -> Bool
<= Int
179 Bool -> Bool -> Bool
&& Int
numTest forall a. Eq a => a -> a -> Bool
/= Int
1 then do
     String -> IO ()
putStrLn String
"Feet   Val  Stat   Proxim" 
     forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM (\(Int8
q,[Int8]
qs) -> let m :: Int
m = Int -> (Int8, [Int8]) -> Int
stat1 Int
syllN (Int8
q,[Int8]
qs)
                          (String
min1, String
max1) = forall a. Ord a => (a -> a -> Ordering) -> [a] -> (a, a)
minMax11ByCList (forall a b. Ord a => (b -> a) -> b -> b -> Ordering
comparing ([[[[Int8]]] -> [[Double]]] -> Int8 -> [Int8] -> String -> Integer
f [[[[Int8]]] -> [[Double]]]
syllableDurationsDs Int8
q [Int8]
qs)) [String]
universalSet 
                          mx :: Integer
mx = [[[[Int8]]] -> [[Double]]] -> Int8 -> [Int8] -> String -> Integer
f [[[[Int8]]] -> [[Double]]]
syllableDurationsDs Int8
q [Int8]
qs String
max1 
                          strTest :: String
strTest = (forall a. Show a => a -> String
show (forall a. Enum a => a -> Int
fromEnum Int8
q) forall a. Monoid a => a -> a -> a
`mappend` String
"   |   " forall a. Monoid a => a -> a -> a
`mappend`  forall a. Show a => a -> String
show Integer
mx forall a. Monoid a => a -> a -> a
`mappend` String
"     " forall a. Monoid a => a -> a -> a
`mappend` forall a. Show a => a -> String
show Int
m forall a. Monoid a => a -> a -> a
`mappend` String
"  -> " forall a. Monoid a => a -> a -> a
`mappend` 
                             forall a. RealFloat a => Maybe Int -> a -> ShowS
showFFloat (forall a. a -> Maybe a
Just Int
3) (Double
100 forall a. Num a => a -> a -> a
* forall a b. (Integral a, Num b) => a -> b
fromIntegral Integer
mx forall a. Fractional a => a -> a -> a
/ forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
m) String
"%" forall a. Monoid a => a -> a -> a
`mappend` (if forall a. Integral a => a -> a -> a
rem Int
numTest Int
10 forall a. Ord a => a -> a -> Bool
>= Int
4 
                                                                                                             then (String
"\n" forall a. Monoid a => a -> a -> a
`mappend` String
min1 forall a. Monoid a => a -> a -> a
`mappend` String
"\n" forall a. Monoid a => a -> a -> a
`mappend` String
max1 forall a. Monoid a => a -> a -> a
`mappend` String
"\n")
                                                                                                             else String
"")) in String -> IO ()
putStrLn String
strTest forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall (m :: * -> *) a. Monad m => a -> m a
return String
strTest) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. [a] -> [b] -> [(a, b)]
zip (forall {a}. (Num a, Enum a) => Int -> [a]
sel2 Int
numTest) forall a b. (a -> b) -> a -> b
$ (forall {a} {a}. (Ord a, Num a, Num a) => a -> [[a]]
sel Int
numTest)
   else let sRepresent :: [PhladiprelioUkr]
sRepresent = forall a b c. (a -> b -> c) -> [a] -> [b] -> [c]
zipWith (\Int
k (Integer
x, String
ys) -> Int -> Integer -> String -> PhladiprelioUkr
S Int
k Integer
x String
ys) [Int
1..] forall b c a. (b -> c) -> (a -> b) -> a -> c
. 
                   (let h1 :: (Integer, b) -> (Integer, b)
h1 = if Bool
descending then (\(Integer
u,b
w) -> ((-Integer
1) forall a. Num a => a -> a -> a
* Integer
u, b
w)) else forall a. a -> a
id in forall b a. Ord b => (a -> b) -> [a] -> [a]
sortOn forall {b}. (Integer, b) -> (Integer, b)
h1) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a -> b) -> [a] -> [b]
map (\String
xss -> ([[[[Int8]]] -> [[Double]]] -> Int8 -> [Int8] -> String -> Integer
f [[[[Int8]]] -> [[Double]]]
syllableDurationsDs Int8
grps [Int8]
mxms String
xss, String
xss)) forall a b. (a -> b) -> a -> b
$ [String]
universalSet
            strOutput :: [String]
strOutput = (forall a. a -> [a] -> [a]
:[]) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (Show a, Eq b) => (a -> b) -> Int8 -> [a] -> String
halfsplit (\(S Int
_ Integer
y String
_) -> Integer
y) (forall {a}. Integral a => a -> a
jjj Int8
splitting) forall a b. (a -> b) -> a -> b
$ [PhladiprelioUkr]
sRepresent
                        in do
                             [()]
_ <- forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM String -> IO ()
putStrLn [String]
strOutput
                             let l1 :: Int
l1 = forall (t :: * -> *) a. Foldable t => t a -> Int
length [PhladiprelioUkr]
sRepresent
                             if Int
code forall a. Eq a => a -> a -> Bool
== -Int
1 
                                 then forall (m :: * -> *) a. Monad m => a -> m a
return [String]
strOutput
                                 else Int -> IO Int
parseLineNumber Int
l1 forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \Int
num -> do
                                         Permissions
permiss <- String -> IO Permissions
getPermissions String
fs
                                         let writ :: Bool
writ = Permissions -> Bool
writable Permissions
permiss
                                             readab :: Bool
readab = Permissions -> Bool
readable Permissions
permiss
                                         if Bool
writ Bool -> Bool -> Bool
&& Bool
readab then String -> String -> IO ()
appendFile String
fs (forall a b c. (a -> b -> c) -> b -> a -> c
flip PhladiprelioUkr -> Int -> String
outputSel Int
code forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. [a] -> a
head forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. (a -> Bool) -> [a] -> [a]
filter (\(S Int
k Integer
_ String
_) -> Int
k forall a. Eq a => a -> a -> Bool
== Int
num) forall a b. (a -> b) -> a -> b
$ [PhladiprelioUkr]
sRepresent)
                                         else forall a. HasCallStack => String -> a
error String
"The specified file cannot be used for appending the text! Please, specify another file!"
                                         forall (m :: * -> *) a. Monad m => a -> m a
return []
     where sel :: a -> [[a]]
sel a
x 
              | a
x forall a. Eq a => a -> a -> Bool
== a
1 Bool -> Bool -> Bool
|| a
x forall a. Ord a => a -> a -> Bool
< a
0 Bool -> Bool -> Bool
|| a
x forall a. Ord a => a -> a -> Bool
> a
179 = []
              | a
x forall a. Eq a => a -> a -> Bool
== a
0 Bool -> Bool -> Bool
|| a
x forall a. Eq a => a -> a -> Bool
== a
4 = [[a
1],[a
2,a
1],[a
3,a
2],[a
4,a
3,a
2],[a
5,a
4,a
3],[a
6,a
5,a
4,a
3,a
2]]  -- all cases are present: 2, 3, 4, 5, 6, 7. Therefore, the slowest ones.
              | a
x forall a. Eq a => a -> a -> Bool
== a
2 Bool -> Bool -> Bool
|| a
x forall a. Eq a => a -> a -> Bool
== a
5 = [[a
1],[a
2],[a
3],[a
4,a
3],[a
5,a
4],[a
6,a
5,a
4]]
              | a
x forall a. Eq a => a -> a -> Bool
== a
7 = [[a
0],[a
1,a
0],[a
1,a
0],[a
1,a
0],[a
1,a
0],[a
1,a
0]]
              | a
x forall a. Eq a => a -> a -> Bool
== a
8 = [[a
0],[a
1,a
0],[a
1,a
0],[a
2,a
1,a
0],[a
2,a
1,a
0],[a
2,a
1,a
0]]
              | a
x forall a. Eq a => a -> a -> Bool
== a
9 = [[a
0],[a
1,a
0],[a
1,a
0],[a
2,a
1,a
0],[a
3,a
2,a
1,a
0],[a
3,a
2,a
1,a
0]]
-----------------------------------------------------------------------------
              | a
x forall a. Ord a => a -> a -> Bool
>= a
20 Bool -> Bool -> Bool
&& a
x forall a. Ord a => a -> a -> Bool
<= a
26 Bool -> Bool -> Bool
&& a
x forall a. Eq a => a -> a -> Bool
/= a
21 = [[a
1]]  -- at least 7 is omitted, but probably 6, or even 5, or even 4, or even 3. 2 is however present.
              | a
x forall a. Ord a => a -> a -> Bool
>= a
27 Bool -> Bool -> Bool
&& a
x forall a. Ord a => a -> a -> Bool
<= a
29 = [[a
0]]
              | a
x forall a. Eq a => a -> a -> Bool
== a
30 Bool -> Bool -> Bool
|| a
x forall a. Eq a => a -> a -> Bool
== a
34 = [[a
1],[a
2,a
1]]
              | a
x forall a. Eq a => a -> a -> Bool
== a
32 Bool -> Bool -> Bool
|| a
x forall a. Eq a => a -> a -> Bool
== a
35 = [[a
1],[a
2]]
              | a
x forall a. Ord a => a -> a -> Bool
>= a
37 Bool -> Bool -> Bool
&& a
x forall a. Ord a => a -> a -> Bool
<= a
39 = [[a
0],[a
1,a
0]]
              | a
x forall a. Eq a => a -> a -> Bool
== a
40 Bool -> Bool -> Bool
|| a
x forall a. Eq a => a -> a -> Bool
== a
44 = [[a
1],[a
2,a
1],[a
3,a
2]]
              | a
x forall a. Eq a => a -> a -> Bool
== a
42 Bool -> Bool -> Bool
|| a
x forall a. Eq a => a -> a -> Bool
== a
45 = [[a
1],[a
2],[a
3]]
              | a
x forall a. Ord a => a -> a -> Bool
>= a
47 Bool -> Bool -> Bool
&& a
x forall a. Ord a => a -> a -> Bool
<= a
49 = [[a
0],[a
1,a
0],[a
1,a
0]]
              | a
x forall a. Eq a => a -> a -> Bool
== a
50 Bool -> Bool -> Bool
|| a
x forall a. Eq a => a -> a -> Bool
== a
54 = [[a
1],[a
2,a
1],[a
3,a
2],[a
4,a
3,a
2]]
              | a
x forall a. Eq a => a -> a -> Bool
== a
52 Bool -> Bool -> Bool
|| a
x forall a. Eq a => a -> a -> Bool
== a
55 = [[a
1],[a
2],[a
3],[a
4,a
3]]
              | a
x forall a. Eq a => a -> a -> Bool
== a
57 = [[a
0],[a
1,a
0],[a
1,a
0],[a
1,a
0]]
              | a
x forall a. Eq a => a -> a -> Bool
== a
58 Bool -> Bool -> Bool
|| a
x forall a. Eq a => a -> a -> Bool
== a
59 = [[a
0],[a
1,a
0],[a
1,a
0],[a
2,a
1,a
0]]
              | a
x forall a. Eq a => a -> a -> Bool
== a
60 Bool -> Bool -> Bool
|| a
x forall a. Eq a => a -> a -> Bool
== a
64 = [[a
1],[a
2,a
1],[a
3,a
2],[a
4,a
3,a
2],[a
5,a
4,a
3]]
              | a
x forall a. Eq a => a -> a -> Bool
== a
62 Bool -> Bool -> Bool
|| a
x forall a. Eq a => a -> a -> Bool
== a
65 = [[a
1],[a
2],[a
3],[a
4,a
3],[a
5,a
4]]
              | a
x forall a. Eq a => a -> a -> Bool
== a
67 = [[a
0],[a
1,a
0],[a
1,a
0],[a
1,a
0],[a
1,a
0]]
              | a
x forall a. Eq a => a -> a -> Bool
== a
68 = [[a
0],[a
1,a
0],[a
1,a
0],[a
2,a
1,a
0],[a
2,a
1,a
0]]
              | a
x forall a. Eq a => a -> a -> Bool
== a
69 = [[a
0],[a
1,a
0],[a
1,a
0],[a
2,a
1,a
0],[a
3,a
2,a
1,a
0]]
-----------------------------------------------------------------
              | a
x forall a. Eq a => a -> a -> Bool
== a
70 Bool -> Bool -> Bool
|| a
x forall a. Eq a => a -> a -> Bool
== a
74 = [[a
2,a
1],[a
3,a
2],[a
4,a
3,a
2],[a
5,a
4,a
3],[a
6,a
5,a
4,a
3,a
2]]  -- at least 2 is omitted, but probably 3 and even 4. 5, 6 and 7 are present.
              | a
x forall a. Eq a => a -> a -> Bool
== a
72 Bool -> Bool -> Bool
|| a
x forall a. Eq a => a -> a -> Bool
== a
75 = [[a
2],[a
3],[a
4,a
3],[a
5,a
4],[a
6,a
5,a
4]]
              | a
x forall a. Eq a => a -> a -> Bool
== a
77 = [[a
1,a
0],[a
1,a
0],[a
1,a
0],[a
1,a
0],[a
1,a
0]]
              | a
x forall a. Eq a => a -> a -> Bool
== a
78 = [[a
1,a
0],[a
1,a
0],[a
2,a
1,a
0],[a
2,a
1,a
0],[a
2,a
1,a
0]]
              | a
x forall a. Eq a => a -> a -> Bool
== a
79 = [[a
1,a
0],[a
1,a
0],[a
2,a
1,a
0],[a
3,a
2,a
1,a
0],[a
3,a
2,a
1,a
0]]
              | a
x forall a. Eq a => a -> a -> Bool
== a
80 Bool -> Bool -> Bool
|| a
x forall a. Eq a => a -> a -> Bool
== a
84 = [[a
3,a
2],[a
4,a
3,a
2],[a
5,a
4,a
3],[a
6,a
5,a
4,a
3,a
2]]
              | a
x forall a. Eq a => a -> a -> Bool
== a
82 Bool -> Bool -> Bool
|| a
x forall a. Eq a => a -> a -> Bool
== a
85 = [[a
3],[a
4,a
3],[a
5,a
4],[a
6,a
5,a
4]]
              | a
x forall a. Eq a => a -> a -> Bool
== a
87 = [[a
1,a
0],[a
1,a
0],[a
1,a
0],[a
1,a
0]]
              | a
x forall a. Eq a => a -> a -> Bool
== a
88 = [[a
1,a
0],[a
2,a
1,a
0],[a
2,a
1,a
0],[a
2,a
1,a
0]]
              | a
x forall a. Eq a => a -> a -> Bool
== a
89 = [[a
1,a
0],[a
2,a
1,a
0],[a
3,a
2,a
1,a
0],[a
3,a
2,a
1,a
0]]
              | a
x forall a. Eq a => a -> a -> Bool
== a
90 Bool -> Bool -> Bool
|| a
x forall a. Eq a => a -> a -> Bool
== a
94 = [[a
4,a
3,a
2],[a
5,a
4,a
3],[a
6,a
5,a
4,a
3,a
2]]
              | a
x forall a. Eq a => a -> a -> Bool
== a
92 Bool -> Bool -> Bool
|| a
x forall a. Eq a => a -> a -> Bool
== a
95 = [[a
4,a
3],[a
5,a
4],[a
6,a
5,a
4]]
              | a
x forall a. Eq a => a -> a -> Bool
== a
97 = [[a
1,a
0],[a
1,a
0],[a
1,a
0]]
              | a
x forall a. Eq a => a -> a -> Bool
== a
98 = [[a
2,a
1,a
0],[a
2,a
1,a
0],[a
2,a
1,a
0]]
              | a
x forall a. Eq a => a -> a -> Bool
== a
99 = [[a
2,a
1,a
0],[a
3,a
2,a
1,a
0],[a
3,a
2,a
1,a
0]]
-----------------------------------------------------------------------------------
              | a
x forall a. Eq a => a -> a -> Bool
== a
100 Bool -> Bool -> Bool
|| a
x forall a. Eq a => a -> a -> Bool
== a
104 = [[a
1],[a
2,a
1],[a
4,a
3,a
2],[a
6,a
5,a
4,a
3,a
2]]  -- 4 and 6 are omitted, just present the ones from: 2, 3, 5, 7.
              | a
x forall a. Eq a => a -> a -> Bool
== a
102 Bool -> Bool -> Bool
|| a
x forall a. Eq a => a -> a -> Bool
== a
105 = [[a
1],[a
2],[a
4,a
3],[a
6,a
5,a
4]]
              | a
x forall a. Eq a => a -> a -> Bool
== a
107 = [[a
0],[a
1,a
0],[a
1,a
0],[a
1,a
0]]
              | a
x forall a. Eq a => a -> a -> Bool
== a
108 = [[a
0],[a
1,a
0],[a
2,a
1,a
0],[a
2,a
1,a
0]]
              | a
x forall a. Eq a => a -> a -> Bool
== a
109 = [[a
0],[a
1,a
0],[a
2,a
1,a
0],[a
3,a
2,a
1,a
0]]
-----------------------------------------------------------------------------
              | a
x forall a. Eq a => a -> a -> Bool
== a
150 Bool -> Bool -> Bool
|| a
x forall a. Eq a => a -> a -> Bool
== a
154 = [[a
1],[a
2,a
1],[a
4,a
3,a
2]]  -- 4, 6, 7 are omitted but 2, 3, 5 are present.
              | a
x forall a. Eq a => a -> a -> Bool
== a
152 Bool -> Bool -> Bool
|| a
x forall a. Eq a => a -> a -> Bool
== a
155 = [[a
1],[a
2],[a
4,a
3]]
              | a
x forall a. Eq a => a -> a -> Bool
== a
157 = [[a
0],[a
1,a
0],[a
1,a
0]]
              | a
x forall a. Eq a => a -> a -> Bool
== a
158 Bool -> Bool -> Bool
|| a
x forall a. Eq a => a -> a -> Bool
== a
159 = [[a
0],[a
1,a
0],[a
2,a
1,a
0]]
-----------------------------------------------------------------
              | a
x forall a. Eq a => a -> a -> Bool
== a
170 Bool -> Bool -> Bool
|| a
x forall a. Eq a => a -> a -> Bool
== a
174 = [[a
2,a
1],[a
4,a
3,a
2],[a
6,a
5,a
4,a
3,a
2]]  -- just 3, 5 and 7 are present
              | a
x forall a. Eq a => a -> a -> Bool
== a
172 Bool -> Bool -> Bool
|| a
x forall a. Eq a => a -> a -> Bool
== a
175 = [[a
2],[a
4,a
3],[a
6,a
5,a
4]]
              | a
x forall a. Eq a => a -> a -> Bool
== a
177 = [[a
1,a
0],[a
1,a
0],[a
1,a
0]]
              | a
x forall a. Eq a => a -> a -> Bool
== a
178 = [[a
1,a
0],[a
2,a
1,a
0],[a
2,a
1,a
0]]
              | a
x forall a. Eq a => a -> a -> Bool
== a
179 = [[a
1,a
0],[a
2,a
1,a
0],[a
3,a
2,a
1,a
0]]
---------------------------------------------------------------------------------- 
              | Bool
otherwise = [[a
1],[a
1],[a
2,a
1],[a
3,a
2,a
1],[a
3,a
2],[a
4,a
3,a
2]]
--------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------
           sel2 :: Int -> [a]
sel2 Int
y 
              | Int
y forall a. Eq a => a -> a -> Bool
== Int
1 Bool -> Bool -> Bool
|| Int
y forall a. Ord a => a -> a -> Bool
< Int
0 Bool -> Bool -> Bool
|| Int
y forall a. Ord a => a -> a -> Bool
> Int
179 = []
              | (forall a. Integral a => a -> a -> a
rem Int
y Int
10 forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [Int
1,Int
3,Int
6]) Bool -> Bool -> Bool
|| Int
y forall a. Ord a => a -> a -> Bool
>= Int
0 Bool -> Bool -> Bool
&& Int
y forall a. Ord a => a -> a -> Bool
<= Int
9 = [a
2..a
7]
              | Int
y forall a. Ord a => a -> a -> Bool
>= Int
20 Bool -> Bool -> Bool
&& Int
y forall a. Ord a => a -> a -> Bool
<= Int
69 = [a
2..forall a. Enum a => Int -> a
toEnum (Int
y forall a. Integral a => a -> a -> a
`quot` Int
10)]
              | Int
y forall a. Ord a => a -> a -> Bool
>= Int
70 Bool -> Bool -> Bool
&& Int
y forall a. Ord a => a -> a -> Bool
<= Int
99 = [forall a. Enum a => Int -> a
toEnum (Int
y forall a. Integral a => a -> a -> a
`quot` Int
10) forall a. Num a => a -> a -> a
- a
4..a
7]
              | Int
y forall a. Ord a => a -> a -> Bool
>= Int
100 Bool -> Bool -> Bool
&& Int
y forall a. Ord a => a -> a -> Bool
<= Int
109 = [a
2,a
3,a
5,a
7]
              | Int
y forall a. Ord a => a -> a -> Bool
>= Int
150 Bool -> Bool -> Bool
&& Int
y forall a. Ord a => a -> a -> Bool
<= Int
159 = [a
2,a
3,a
5]
              | Int
y forall a. Ord a => a -> a -> Bool
>= Int
170 Bool -> Bool -> Bool
&& Int
y forall a. Ord a => a -> a -> Bool
<= Int
179 = [a
3,a
5,a
7]
              | Bool
otherwise = [a
2..a
7]
           minMax11ByCList :: Ord a => (a -> a -> Ordering) -> [a] -> (a, a) -- Is rewritten from the 'Data.MinMax.Preconditions.minMax11ByC' from @subG@ package.
           minMax11ByCList :: forall a. Ord a => (a -> a -> Ordering) -> [a] -> (a, a)
minMax11ByCList a -> a -> Ordering
g xs :: [a]
xs@(a
x:a
y:[a]
ys) = forall a b. (a -> b -> b) -> b -> [a] -> b
foldr a -> (a, a) -> (a, a)
f (if a
x forall a. Ord a => a -> a -> Bool
> a
y then (a
y, a
x) else (a
x, a
y)) [a]
ys
               where f :: a -> (a, a) -> (a, a)
f a
z (a
x,a
y)
                        | a -> a -> Ordering
g a
z a
x forall a. Eq a => a -> a -> Bool
== Ordering
LT = (a
z,a
y)
                        | a -> a -> Ordering
g a
z a
y forall a. Eq a => a -> a -> Bool
== Ordering
GT = (a
x,a
z)
                        | Bool
otherwise = (a
x,a
y)
           minMax11ByCList a -> a -> Ordering
_ [a]
_ = forall a. HasCallStack => a
undefined -- Is not intended to be used for lists with less than two elements.
           jjj :: a -> a
jjj a
kk = let (a
q1,a
r1) = forall a. Integral a => a -> a -> (a, a)
quotRem a
kk (if a
kk forall a. Ord a => a -> a -> Bool
< a
0 then -a
10 else a
10) in forall {a}. (Num a, Ord a) => a -> a -> Bool -> a
jjj' a
q1 a
r1 Bool
emptyline
           jjj' :: a -> a -> Bool -> a
jjj' a
q1 a
r1 Bool
emptyline
             | a
r1 forall a. Eq a => a -> a -> Bool
== (-a
1) Bool -> Bool -> Bool
|| a
r1 forall a. Eq a => a -> a -> Bool
== (-a
3) = -a
10forall a. Num a => a -> a -> a
*a
q1 forall a. Num a => a -> a -> a
+ (if Bool
emptyline then -a
5 else a
r1)
             | a
r1 forall a. Eq a => a -> a -> Bool
== a
1 Bool -> Bool -> Bool
|| a
r1 forall a. Eq a => a -> a -> Bool
== a
3 = a
10forall a. Num a => a -> a -> a
*a
q1 forall a. Num a => a -> a -> a
+ (if Bool
emptyline then a
5 else a
r1)
             | a
r1 forall a. Ord a => a -> a -> Bool
< a
0 = -a
10forall a. Num a => a -> a -> a
*a
q1 forall a. Num a => a -> a -> a
+ (if Bool
emptyline then -a
4 else a
r1)
             | Bool
otherwise = a
10forall a. Num a => a -> a -> a
*a
q1 forall a. Num a => a -> a -> a
+ (if Bool
emptyline then a
4 else a
r1)
generalF String
_ Int
_ HashCorrections
_ (Int8, [Int8])
_ Int
_ Bool
_ Int
_ Bool
_ Int8
_ (String, Int)
_ [String
u1] = forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM String -> IO ()
putStrLn [String
u1] forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall (m :: * -> *) a. Monad m => a -> m a
return [String
u1]
generalF String
_ Int
_ HashCorrections
_ (Int8, [Int8])
_ Int
_ Bool
_ Int
_ Bool
_ Int8
_ (String, Int)
_ [String]
_ = let strOutput :: [String]
strOutput = [String
"You have specified the data and constraints on it that lead to no further possible options.", String
"Please, specify another data and constraints."] in forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM String -> IO ()
putStrLn [String]
strOutput forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall (m :: * -> *) a. Monad m => a -> m a
return [String]
strOutput

data PhladiprelioUkr = S Int Integer String deriving PhladiprelioUkr -> PhladiprelioUkr -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PhladiprelioUkr -> PhladiprelioUkr -> Bool
$c/= :: PhladiprelioUkr -> PhladiprelioUkr -> Bool
== :: PhladiprelioUkr -> PhladiprelioUkr -> Bool
$c== :: PhladiprelioUkr -> PhladiprelioUkr -> Bool
Eq

instance Show PhladiprelioUkr where
  show :: PhladiprelioUkr -> String
show (S Int
i Integer
j String
xs) = Int -> Integer -> String
showBignum Int
7 Integer
j forall a. Monoid a => a -> a -> a
`mappend` String
" " forall a. Monoid a => a -> a -> a
`mappend` String
xs forall a. Monoid a => a -> a -> a
`mappend` String
"  " forall a. Monoid a => a -> a -> a
`mappend` forall a. Show a => Int -> a -> String
showWithSpaces Int
4 Int
i

countSyll :: String -> Int
countSyll :: String -> Int
countSyll String
xs = forall a. Enum a => a -> Int
fromEnum forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a -> b -> b) -> b -> [a] -> b
foldr (\Int8
x Integer
y -> if Int8 -> Bool
isVowel1 Int8
x then Integer
y forall a. Num a => a -> a -> a
+ Integer
1 else Integer
y) Integer
0 forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> [Int8]
convertToProperUkrainianI8 forall a b. (a -> b) -> a -> b
$ String
xs

stat1 :: Int -> (Int8,[Int8]) -> Int
stat1 :: Int -> (Int8, [Int8]) -> Int
stat1 Int
n (Int8
k, [Int8]
ks) = forall a b. (a, b) -> a
fst (Int
n Int -> Int -> (Int, Int)
`quotRemInt` forall a. Enum a => a -> Int
fromEnum Int8
k) forall a. Num a => a -> a -> a
* forall (t :: * -> *) a. Foldable t => t a -> Int
length [Int8]
ks

parseHelp :: [String] -> (String,[String])
parseHelp :: [String] -> (String, [String])
parseHelp [String]
xss 
  | forall (t :: * -> *) a. Foldable t => t a -> Bool
null [String]
xss = ([],[])
  | Bool
otherwise = ([String] -> String
unwords [String]
rss, [String]
uss forall a. Monoid a => a -> a -> a
`mappend` [String]
qss)
       where ([String]
yss,[String]
tss) = forall a. (a -> Bool) -> [a] -> ([a], [a])
break (forall a. Eq a => a -> a -> Bool
== String
"-b") [String]
xss
             ([String]
uss,[String]
wss) = forall a. (a -> Bool) -> [a] -> ([a], [a])
break (forall a. Eq a => a -> a -> Bool
== String
"+b") [String]
yss
             [[String]
qss,[String]
rss] = forall a b. (a -> b) -> [a] -> [b]
map (forall a. Int -> [a] -> [a]
drop Int
1) [[String]
tss, [String]
wss]
             
outputSel :: PhladiprelioUkr -> Int -> String
outputSel :: PhladiprelioUkr -> Int -> String
outputSel (S Int
x1 Integer
y1 String
ts) Int
code
  | Int
code forall a. Ord a => a -> a -> Bool
< Int
0 = []
  | Int
code forall a. Eq a => a -> a -> Bool
== Int
0 = String
ts forall a. Monoid a => a -> a -> a
`mappend` String
"\n"
  | Int
code forall a. Eq a => a -> a -> Bool
== Int
1 = forall a. [a] -> [[a]] -> [a]
intercalate String
" " [forall a. Show a => a -> String
show Int
x1, String
ts] forall a. Monoid a => a -> a -> a
`mappend` String
"\n"
  | Int
code forall a. Eq a => a -> a -> Bool
== Int
2 = forall a. [a] -> [[a]] -> [a]
intercalate String
" " [forall a. Show a => a -> String
show Integer
y1, String
ts] forall a. Monoid a => a -> a -> a
`mappend` String
"\n"
  | Int
code forall a. Eq a => a -> a -> Bool
== Int
3 = forall a. [a] -> [[a]] -> [a]
intercalate String
" " [forall a. Show a => a -> String
show Int
x1, String
ts, forall a. Show a => a -> String
show Integer
y1] forall a. Monoid a => a -> a -> a
`mappend` String
"\n"
  | Int
code forall a. Eq a => a -> a -> Bool
== Int
4 = forall a. [a] -> [[a]] -> [a]
intercalate String
" " [forall a. Show a => a -> String
show Int
x1, forall a. Show a => a -> String
show Integer
y1] forall a. Monoid a => a -> a -> a
`mappend` String
"\n"
  | Bool
otherwise = String
ts forall a. Monoid a => a -> a -> a
`mappend` String
"\n"

parseLineNumber :: Int -> IO Int
parseLineNumber :: Int -> IO Int
parseLineNumber Int
l1 = do 
  String -> IO ()
putStrLn String
"Please, specify the number of the option to be written to the file specified: "
  String
number <- IO String
getLine
  let num :: Maybe Int
num = forall a. Read a => String -> Maybe a
readMaybe (forall a. (a -> Bool) -> [a] -> [a]
filter Char -> Bool
isDigit String
number)::Maybe Int
  if forall a. Maybe a -> Bool
isNothing Maybe Int
num Bool -> Bool -> Bool
|| Maybe Int
num forall a. Ord a => a -> a -> Bool
> forall a. a -> Maybe a
Just Int
l1 Bool -> Bool -> Bool
|| Maybe Int
num forall a. Eq a => a -> a -> Bool
== forall a. a -> Maybe a
Just Int
0 
      then Int -> IO Int
parseLineNumber Int
l1 
      else forall (m :: * -> *) a. Monad m => a -> m a
return forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. HasCallStack => Maybe a -> a
fromJust forall a b. (a -> b) -> a -> b
$ Maybe Int
num