{-# LANGUAGE NoImplicitPrelude #-}
{-# OPTIONS_HADDOCK -show-extensions #-}

{- |
Module      :  Aftovolio.Halfsplit
Copyright   :  (c) OleksandrZhabenko 2023
License     :  MIT
Stability   :  Experimental
Maintainer  :  oleksandr.zhabenko@yahoo.com
-}
module Aftovolio.Halfsplit where

import Data.Char (isDigit)
import Data.List hiding (foldr)
import Data.Tuple (fst)
import GHC.Base
import GHC.Enum (fromEnum)
import GHC.Int (Int8)
import GHC.Num (abs, (+), (-))
import GHC.Real (quot, quotRem)
import System.IO (getLine, putStr, putStrLn)
import Text.Read (readMaybe)
import Data.Maybe (Maybe,fromMaybe)
import Text.Show (Show (..))
import Debug.Trace

-- | Converts the data that is an instance of 'Show' typeclass to be printed in two-column way.
halfsplit ::
    (Show a, Eq b) =>
    (a -> b) ->
    -- | Whether to filter out all groups of \'={digits}\' from the lines.
    Bool ->
    Int8 ->
    [a] ->
    String
halfsplit :: forall a b.
(Show a, Eq b) =>
(a -> b) -> Bool -> Int8 -> [a] -> [Char]
halfsplit a -> b
g Bool
filtering = (a -> b) -> Bool -> [Char] -> Int8 -> [a] -> [Char]
forall a b.
(Show a, Eq b) =>
(a -> b) -> Bool -> [Char] -> Int8 -> [a] -> [Char]
halfsplit1G a -> b
g Bool
filtering [Char]
""
{-# INLINE halfsplit #-}

{- | Converts the data that is an instance of 'Show' typeclass to be printed in two-column way with
customizable ending of each line. Filters out all groups of \'={digits}\' from the lines.
-}
halfsplit1G ::
    (Show a, Eq b) =>
    (a -> b) ->
    -- | Whether to filter out all groups of \'={digits}\' from the lines.
    Bool ->
    -- | Additional 'String' added to every line before the \"\\n\" character.
    String ->
    Int8 ->
    [a] ->
    String
halfsplit1G :: forall a b.
(Show a, Eq b) =>
(a -> b) -> Bool -> [Char] -> Int8 -> [a] -> [Char]
halfsplit1G a -> b
g Bool
filtering [Char]
appendstr Int8
m [a]
xs
    | [a] -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [a]
xs = []
    | Bool
otherwise =
        let (Int
n, Int
rr2) = Int -> Int -> (Int, Int)
forall a. Integral a => a -> a -> (a, a)
quotRem (Int8 -> Int
forall a. Enum a => a -> Int
fromEnum Int8
m) (if Int8
m Int8 -> Int8 -> Bool
forall a. Ord a => a -> a -> Bool
< Int8
0 then -Int
10 else Int
10)
            r :: ([[Char]], [[Char]])
r =
                case Int -> Int
forall a. Num a => a -> a
abs Int
rr2 of
                    Int
1 ->
                        let us :: [a]
us = [a] -> [a]
forall a. [a] -> [a]
reverse [a]
ts
                         in ((if Int
rrr Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
0 then [[Char]] -> [[Char]]
forall a. a -> a
id else (Int -> Char -> [Char]
forall a. Int -> a -> [a]
replicate Int
l0 Char
' ' [Char] -> [[Char]] -> [[Char]]
forall a. a -> [a] -> [a]
:)) ([[Char]] -> [[Char]]) -> [[Char]] -> [[Char]]
forall a b. (a -> b) -> a -> b
$ (a -> [Char]) -> [a] -> [[Char]]
forall a b. (a -> b) -> [a] -> [b]
map a -> [Char]
forall a. Show a => a -> [Char]
show [a]
ys, (a -> [Char]) -> [a] -> [[Char]]
forall a b. (a -> b) -> [a] -> [b]
map a -> [Char]
forall a. Show a => a -> [Char]
show [a]
us)
                    Int
2 -> ([[Char]] -> [[Char]]
forall a. [a] -> [a]
reverse [[Char]]
y10s, [[Char]]
t10s)
                    Int
3 -> ([[Char]]
y10s, [[Char]] -> [[Char]]
forall a. [a] -> [a]
reverse [[Char]]
t10s)
                    Int
4 -> ([[Char]] -> [[Char]]
forall a. [a] -> [a]
reverse [[Char]]
y20s, [[Char]]
t20s)
                    Int
5 -> ([[Char]]
y20s, [[Char]] -> [[Char]]
forall a. [a] -> [a]
reverse [[Char]]
t20s)
                    Int
_ ->
                        let us :: [a]
us = [a] -> [a]
forall a. [a] -> [a]
reverse [a]
ys
                         in ((if Int
rrr Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
0 then [[Char]] -> [[Char]]
forall a. a -> a
id else (Int -> Char -> [Char]
forall a. Int -> a -> [a]
replicate Int
l0 Char
' ' [Char] -> [[Char]] -> [[Char]]
forall a. a -> [a] -> [a]
:)) ([[Char]] -> [[Char]]) -> [[Char]] -> [[Char]]
forall a b. (a -> b) -> a -> b
$ (a -> [Char]) -> [a] -> [[Char]]
forall a b. (a -> b) -> [a] -> [b]
map a -> [Char]
forall a. Show a => a -> [Char]
show [a]
us, (a -> [Char]) -> [a] -> [[Char]]
forall a b. (a -> b) -> [a] -> [b]
map a -> [Char]
forall a. Show a => a -> [Char]
show [a]
ts)
         in (if Bool
filtering then [Char] -> [Char]
removeChangesOfDurations else [Char] -> [Char]
forall a. a -> a
id) ([Char] -> [Char]) -> [Char] -> [Char]
forall a b. (a -> b) -> a -> b
$
                ((\([[Char]]
rs, [[Char]]
qs) -> Int -> [Char] -> [[Char]] -> [[Char]] -> [Char]
mergePartsLine Int
n ([Char]
appendstr [Char] -> [Char] -> [Char]
forall a. Monoid a => a -> a -> a
`mappend` [Char]
"\n") [[Char]]
rs [[Char]]
qs) ([[Char]], [[Char]])
r)
                    [Char] -> [Char] -> [Char]
forall a. Monoid a => a -> a -> a
`mappend` [Char]
appendstr
  where
    ([a]
ys, [a]
ts) = Int -> [a] -> ([a], [a])
forall a. Int -> [a] -> ([a], [a])
splitAt Int
l [a]
xs -- Is used for basic splitting
    (Int
l, Int
rrr) = [a] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [a]
xs Int -> Int -> (Int, Int)
forall a. Integral a => a -> a -> (a, a)
`quotRem` Int
2 -- For basic splitting
    l0 :: Int
l0 = [Char] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length ([Char] -> Int) -> ([a] -> [Char]) -> [a] -> Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> [Char]
forall a. Show a => a -> [Char]
show (a -> [Char]) -> ([a] -> a) -> [a] -> [Char]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [a] -> a
forall a. HasCallStack => [a] -> a
head ([a] -> Int) -> [a] -> Int
forall a b. (a -> b) -> a -> b
$ [a]
xs  -- For all cases for a whitespace placeholder
    rss :: [[[Char]]]
rss = ([a] -> [[Char]]) -> [[a]] -> [[[Char]]]
forall a b. (a -> b) -> [a] -> [b]
map ((a -> [Char]) -> [a] -> [[Char]]
forall a b. (a -> b) -> [a] -> [b]
map a -> [Char]
forall a. Show a => a -> [Char]
show) ([[a]] -> [[[Char]]]) -> ([a] -> [[a]]) -> [a] -> [[[Char]]]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> a -> Bool) -> [a] -> [[a]]
forall a. (a -> a -> Bool) -> [a] -> [[a]]
groupBy (\a
x a
y -> a -> b
g a
x b -> b -> Bool
forall a. Eq a => a -> a -> Bool
== a -> b
g a
y) ([a] -> [[[Char]]]) -> [a] -> [[[Char]]]
forall a b. (a -> b) -> a -> b
$ [a]
xs -- For basic groupping
    (Int
l2, Int
r20) = ([Int] -> Int
forall a. Num a => [a] -> a
forall (t :: * -> *) a. (Foldable t, Num a) => t a -> a
sum ([Int] -> Int) -> ([[[Char]]] -> [Int]) -> [[[Char]]] -> Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ([[Char]] -> Int) -> [[[Char]]] -> [Int]
forall a b. (a -> b) -> [a] -> [b]
map [[Char]] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length ([[[Char]]] -> Int) -> [[[Char]]] -> Int
forall a b. (a -> b) -> a -> b
$ [[[Char]]]
rss) Int -> Int -> (Int, Int)
forall a. Integral a => a -> a -> (a, a)
`quotRem` Int
2
    ([[Char]]
y100s, [[Char]]
t10s) = Int -> [[Char]] -> ([[Char]], [[Char]])
forall a. Int -> [a] -> ([a], [a])
splitAt Int
l2 ([[Char]] -> ([[Char]], [[Char]]))
-> ([[[Char]]] -> [[Char]]) -> [[[Char]]] -> ([[Char]], [[Char]])
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [[[Char]]] -> [[Char]]
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat ([[[Char]]] -> ([[Char]], [[Char]]))
-> [[[Char]]] -> ([[Char]], [[Char]])
forall a b. (a -> b) -> a -> b
$ [[[Char]]]
rss
    y10s :: [[Char]]
y10s 
        | Int
r20 Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
0 = [[Char]]
y100s
        | Bool
otherwise = Int -> Char -> [Char]
forall a. Int -> a -> [a]
replicate Int
l0 Char
' ' [Char] -> [[Char]] -> [[Char]]
forall a. a -> [a] -> [a]
: [[Char]]
y100s
    r1ss :: [[[Char]]]
r1ss = [[Char]] -> [[[Char]]] -> [[[Char]]]
forall a. a -> [a] -> [a]
intersperse [Int -> Char -> [Char]
forall a. Int -> a -> [a]
replicate Int
l0 Char
' '] [[[Char]]]
rss -- For groupping with empty lines
    (Int
l3, Int
r30) = ([Int] -> Int
forall a. Num a => [a] -> a
forall (t :: * -> *) a. (Foldable t, Num a) => t a -> a
sum ([Int] -> Int) -> ([[[Char]]] -> [Int]) -> [[[Char]]] -> Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ([[Char]] -> Int) -> [[[Char]]] -> [Int]
forall a b. (a -> b) -> [a] -> [b]
map [[Char]] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length ([[[Char]]] -> Int) -> [[[Char]]] -> Int
forall a b. (a -> b) -> a -> b
$ [[[Char]]]
r1ss) Int -> Int -> (Int, Int)
forall a. Integral a => a -> a -> (a, a)
`quotRem` Int
2
    ([[Char]]
y200s, [[Char]]
t20s) = Int -> [[Char]] -> ([[Char]], [[Char]])
forall a. Int -> [a] -> ([a], [a])
splitAt Int
l3 ([[Char]] -> ([[Char]], [[Char]]))
-> ([[[Char]]] -> [[Char]]) -> [[[Char]]] -> ([[Char]], [[Char]])
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [[[Char]]] -> [[Char]]
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat ([[[Char]]] -> ([[Char]], [[Char]]))
-> [[[Char]]] -> ([[Char]], [[Char]])
forall a b. (a -> b) -> a -> b
$ [[[Char]]]
r1ss
    y20s :: [[Char]]
y20s
        | Int
r30 Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
0 = [[Char]]
y200s
        | Bool
otherwise = Int -> Char -> [Char]
forall a. Int -> a -> [a]
replicate Int
l0 Char
' ' [Char] -> [[Char]] -> [[Char]]
forall a. a -> [a] -> [a]
: [[Char]]
y200s
 
-- | A generalized version of 'halfsplit3G' with the possibility to prepend and append strings to it. These 'String's are not filtered out for the groups of \'={digits}\' from the prepending and appending 'String's.
halfsplit2G ::
    (Show a, Eq b) =>
    (a -> b) ->
    -- | Whether to filter out all groups of \'={digits}\' from the lines.
    Bool ->
    -- | Additional 'String' added to every line before the \"\\n\" character.
    String ->
    -- | A 'String' that is prepended to the 'halfsplit1G' result.
    String ->
    -- | A 'String' that is appended to the 'halfsplit1G' result.
    String ->
    Int8 ->
    [a] ->
    String
halfsplit2G :: forall a b.
(Show a, Eq b) =>
(a -> b)
-> Bool -> [Char] -> [Char] -> [Char] -> Int8 -> [a] -> [Char]
halfsplit2G a -> b
g Bool
filtering [Char]
appendstr [Char]
prestr [Char]
poststr Int8
m [a]
xs = [Char]
prestr [Char] -> [Char] -> [Char]
forall a. Monoid a => a -> a -> a
`mappend` (a -> b) -> Bool -> [Char] -> Int8 -> [a] -> [Char]
forall a b.
(Show a, Eq b) =>
(a -> b) -> Bool -> [Char] -> Int8 -> [a] -> [Char]
halfsplit1G a -> b
g Bool
filtering [Char]
appendstr Int8
m [a]
xs [Char] -> [Char] -> [Char]
forall a. Monoid a => a -> a -> a
`mappend` [Char]
poststr
{-# INLINEABLE halfsplit2G #-}

-- | Filters out all groups of \'={digits}\' from the 'String'
removeChangesOfDurations :: String -> String
removeChangesOfDurations :: [Char] -> [Char]
removeChangesOfDurations (Char
'=' : [Char]
xs) = [Char] -> [Char]
removeChangesOfDurations ((Char -> Bool) -> [Char] -> [Char]
forall a. (a -> Bool) -> [a] -> [a]
dropWhile Char -> Bool
isDigit [Char]
xs)
removeChangesOfDurations (Char
x : [Char]
xs) = Char
x Char -> [Char] -> [Char]
forall a. a -> [a] -> [a]
: [Char] -> [Char]
removeChangesOfDurations [Char]
xs
removeChangesOfDurations [Char]
_ = []

mergePartsLine :: Int -> String -> [String] -> [String] -> String
mergePartsLine :: Int -> [Char] -> [[Char]] -> [[Char]] -> [Char]
mergePartsLine Int
n [Char]
newlined [[Char]]
xs [[Char]]
ys =
    [Char] -> [[Char]] -> [Char]
forall a. [a] -> [[a]] -> [a]
intercalate [Char]
newlined
        ([[Char]] -> [Char])
-> ([[Char]] -> [[Char]]) -> [[Char]] -> [Char]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ([Char] -> [Char] -> [Char]) -> [[Char]] -> [[Char]] -> [[Char]]
forall a b c. (a -> b -> c) -> [a] -> [b] -> [c]
zipWith
            (\[Char]
x [Char]
y -> [Char]
x [Char] -> [Char] -> [Char]
forall a. Monoid a => a -> a -> a
`mappend` (Int -> Char -> [Char]
forall a. Int -> a -> [a]
replicate Int
n (if Int
n Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Int
0 then Char
'\t' else Char
' ')) [Char] -> [Char] -> [Char]
forall a. Monoid a => a -> a -> a
`mappend` [Char]
y)
            [[Char]]
xs ([[Char]] -> [Char]) -> [[Char]] -> [Char]
forall a b. (a -> b) -> a -> b
$
        [[Char]]
ys

splitGroups :: Int -> [[a]] -> ([[a]], [[a]], Int)
splitGroups :: forall a. Int -> [[a]] -> ([[a]], [[a]], Int)
splitGroups Int
l [[a]]
tss = ([a] -> ([[a]], [[a]], Int) -> ([[a]], [[a]], Int))
-> ([[a]], [[a]], Int) -> [[a]] -> ([[a]], [[a]], Int)
forall a b. (a -> b -> b) -> b -> [a] -> b
foldr [a] -> ([[a]], [[a]], Int) -> ([[a]], [[a]], Int)
forall {t :: * -> *} {a}.
Foldable t =>
t a -> ([t a], [t a], Int) -> ([t a], [t a], Int)
h ([], [], Int
0) [[a]]
tss
  where
    h :: t a -> ([t a], [t a], Int) -> ([t a], [t a], Int)
h t a
js ([t a]
rss, [t a]
mss, Int
k)
        | Int
k Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Int
l = ([t a]
rss, t a
js t a -> [t a] -> [t a]
forall a. a -> [a] -> [a]
: [t a]
mss, Int
k Int -> Int -> Int
forall a. Num a => a -> a -> a
+ t a -> Int
forall a. t a -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length t a
js)
        | Bool
otherwise = (t a
js t a -> [t a] -> [t a]
forall a. a -> [a] -> [a]
: [t a]
rss, [t a]
mss, Int
k Int -> Int -> Int
forall a. Num a => a -> a -> a
+ t a -> Int
forall a. t a -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length t a
js)

showWithSpaces :: (Show a) => Int -> a -> String
showWithSpaces :: forall a. Show a => Int -> a -> [Char]
showWithSpaces Int
n a
x
    | Int
l Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Int
n = [Char]
xs [Char] -> [Char] -> [Char]
forall a. Monoid a => a -> a -> a
`mappend` Int -> Char -> [Char]
forall a. Int -> a -> [a]
replicate (Int
n Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
l) Char
' '
    | Bool
otherwise = [Char]
xs
  where
    xs :: [Char]
xs = a -> [Char]
forall a. Show a => a -> [Char]
show a
x
    l :: Int
l = [Char] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [Char]
xs

print23 :: Bool -> String -> String -> Int -> [String] -> IO ()
print23 :: Bool -> [Char] -> [Char] -> Int -> [[Char]] -> IO ()
print23 Bool
filtering [Char]
prestr [Char]
poststr Int
n [[Char]]
xss = do
    [Char] -> IO ()
putStrLn [Char]
prestr
    let linez :: [([Char], Int)]
linez = [[Char]] -> [Int] -> [([Char], Int)]
forall a b. [a] -> [b] -> [(a, b)]
zip [[Char]]
xss [Int
1 ..]
    if Int
n Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
2 Bool -> Bool -> Bool
&& Int
n Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
<= Int
l Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1
        then do
            let linez3 :: [[Char]]
linez3 =
                    (\([Char]
x : [Char]
y : [Char]
t : [[Char]]
xs) -> [Char]
x [Char] -> [[Char]] -> [[Char]]
forall a. a -> [a] -> [a]
: (Char
' ' Char -> [Char] -> [Char]
forall a. a -> [a] -> [a]
: [Char]
y) [Char] -> [[Char]] -> [[Char]]
forall a. a -> [a] -> [a]
: (Char
' ' Char -> [Char] -> [Char]
forall a. a -> [a] -> [a]
: Char
' ' Char -> [Char] -> [Char]
forall a. a -> [a] -> [a]
: [Char]
t) [Char] -> [[Char]] -> [[Char]]
forall a. a -> [a] -> [a]
: [[Char]]
xs)
                        ([[Char]] -> [[Char]])
-> ([([Char], Int)] -> [[Char]]) -> [([Char], Int)] -> [[Char]]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (([Char], Int) -> [Char]) -> [([Char], Int)] -> [[Char]]
forall a b. (a -> b) -> [a] -> [b]
map ([Char], Int) -> [Char]
forall a b. (a, b) -> a
fst
                        ([([Char], Int)] -> [[Char]])
-> ([([Char], Int)] -> [([Char], Int)])
-> [([Char], Int)]
-> [[Char]]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (([Char], Int) -> Bool) -> [([Char], Int)] -> [([Char], Int)]
forall a. (a -> Bool) -> [a] -> [a]
filter (\([Char]
ts, Int
m) -> Int
m Int -> [Int] -> Bool
forall a. Eq a => a -> [a] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [Int
n Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1 .. Int
n Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1]) ([([Char], Int)] -> [[Char]]) -> [([Char], Int)] -> [[Char]]
forall a b. (a -> b) -> a -> b
$
                        [([Char], Int)]
linez
            ([Char] -> IO ()) -> [[Char]] -> IO [()]
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM [Char] -> IO ()
putSLn [[Char]]
linez3 IO [()] -> IO () -> IO ()
forall a b. IO a -> IO b -> IO b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char] -> IO ()
putStrLn [Char]
poststr
        else
            ( case Int
n of
                Int
1 -> [Char] -> IO ()
putStr [Char]
" " IO () -> IO [()] -> IO [()]
forall a b. IO a -> IO b -> IO b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ([Char] -> IO ()) -> [[Char]] -> IO [()]
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM [Char] -> IO ()
putSLn (Int -> [[Char]] -> [[Char]]
forall a. Int -> [a] -> [a]
take Int
2 [[Char]]
xss)
                Int
m ->
                    if Int
m Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
l
                        then ([Char] -> IO ()) -> [[Char]] -> IO [()]
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM [Char] -> IO ()
putSLn ((\([Char]
x : [Char]
y : [[Char]]
xs) -> [Char]
x [Char] -> [[Char]] -> [[Char]]
forall a. a -> [a] -> [a]
: (Char
' ' Char -> [Char] -> [Char]
forall a. a -> [a] -> [a]
: [Char]
y) [Char] -> [[Char]] -> [[Char]]
forall a. a -> [a] -> [a]
: [[Char]]
xs) ([[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
l Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
2) ([[Char]] -> [[Char]]) -> [[Char]] -> [[Char]]
forall a b. (a -> b) -> a -> b
$ [[Char]]
xss)
                        else [()] -> IO [()]
forall a. a -> IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure []
            )
                IO [()] -> IO () -> IO ()
forall a b. IO a -> IO b -> IO b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char] -> IO ()
putStrLn [Char]
poststr
  where
    l :: Int
l = [[Char]] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [[Char]]
xss
    putSLn :: [Char] -> IO ()
putSLn = [Char] -> IO ()
putStrLn ([Char] -> IO ()) -> ([Char] -> [Char]) -> [Char] -> IO ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (if Bool
filtering then [Char] -> [Char]
removeChangesOfDurations else [Char] -> [Char]
forall a. a -> a
id)

readNums :: [String] -> [Int]
readNums :: [[Char]] -> [Int]
readNums = ([Char] -> [Int]) -> [[Char]] -> [Int]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap [Char] -> [Int]
readNs
  where readNs :: String -> [Int]
        readNs :: [Char] -> [Int]
readNs [Char]
xs 
            | (Char -> Bool) -> [Char] -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
any (Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
'-') [Char]
xs = 
                 let ([Char]
ys, [Char]
ts) = (Char -> Bool) -> [Char] -> ([Char], [Char])
forall a. (a -> Bool) -> [a] -> ([a], [a])
break (Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
'-') [Char]
xs 
                     us :: [Char]
us = (Char -> Bool) -> [Char] -> [Char]
forall a. (a -> Bool) -> [a] -> [a]
dropWhile (Bool -> Bool
not (Bool -> Bool) -> (Char -> Bool) -> Char -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char -> Bool
isDigit) [Char]
ts
                 in [(Int -> Maybe Int -> Int
forall a. a -> Maybe a -> a
fromMaybe Int
1 ([Char] -> Maybe Int
forall a. Read a => [Char] -> Maybe a
readMaybe [Char]
ys:: Maybe Int))..(Int -> Maybe Int -> Int
forall a. a -> Maybe a -> a
fromMaybe Int
1 ([Char] -> Maybe Int
forall a. Read a => [Char] -> Maybe a
readMaybe [Char]
us:: Maybe Int))]
            | Bool
otherwise = [Int -> Maybe Int -> Int
forall a. a -> Maybe a -> a
fromMaybe Int
1 ([Char] -> Maybe Int
forall a. Read a => [Char] -> Maybe a
readMaybe [Char]
xs:: Maybe Int)]
{-# INLINE readNums #-}