module MSS;

import Flite;

init (Cons x Nil) = Nil;
init (Cons x (Cons y ys)) = Cons x (init (Cons y ys));

inits xs = case xs of {
             Nil -> Cons Nil Nil;
             Cons y ys -> Cons xs (inits (init xs));
           };

tails Nil = Nil;
tails (Cons x xs) = Cons (Cons x xs) (tails xs);

map f Nil = Nil;
map f (Cons x xs) = Cons (f x) (map f xs);

append Nil ys = ys;
append (Cons x xs) ys = Cons x (append xs ys);

concatMap f Nil = Nil;
concatMap f (Cons x xs) = append (f x) (concatMap f xs);

segments xs = concatMap tails (inits xs);

maximum (Cons x xs) = maxi x xs;

maxi m Nil = m;
maxi m (Cons x xs) =
  case (<=) m x of { True -> maxi x xs ; False -> maxi m xs };

sum xs = sumAcc 0 xs;

sumAcc acc Nil = acc;
sumAcc acc (Cons x xs) = sumAcc ((+) acc x) xs;

mss xs = maximum (map sum (segments xs));

fromTo n m = case (<=) n m of {
               True -> Cons n (fromTo ((+) n 1) m);
               False -> Nil;
             };

Start = ((+) ((-) (mss (fromTo ((-) 0 160) 160))
                  (mss (fromTo ((-) 0 150) 150)))
             ((-) (mss (fromTo ((-) 0 161) 161))
                  (mss (fromTo ((-) 0 151) 151))));