module Main  where{
import System;
import List;
import Monad;

main::IO(());
main = (do{
  x<-getArgs;
  (case x of {
  ["nothing"]->(return ());
  ["run6"]->run6;
  ["runall"]->runall
});
});
data  Block_element  = If | If_not | Else | Elsif | Endif | S(Int) deriving (Eq,Show);
type Block  = [](Block_element);
block_types::[](Block);
block_types = [[If],[If,Endif],[If,Else],[If,Else,Endif],[If,Elsif],[If,Elsif,Endif],[If,Elsif,Else],[If,Elsif,Else,Endif],[If,Elsif,Elsif],[If,Elsif,Elsif,Endif],[If,Elsif,Elsif,Else],[If,Elsif,Elsif,Else,Endif],[If_not],[If_not,Endif],[If_not,Else],[If_not,Else,Endif],[If_not,Elsif],[If_not,Elsif,Endif],[If_not,Elsif,Else],[If_not,Elsif,Else,Endif],[If_not,Elsif,Elsif],[If_not,Elsif,Elsif,Endif],[If_not,Elsif,Elsif,Else],[If_not,Elsif,Elsif,Else,Endif]];
embeddable_block::Block->Bool;
embeddable_block b = ((==) (last b) Endif);
embeds::[](Block);
embeds = (filter embeddable_block block_types);
try_embed::Block->[](Block);
try_embed b = (do{
  choose_break<-(breaks b);
  e<-embeds;
  (guard (case choose_break of {
  ((_),([]))->(case (embeddable_block b) of {
  (True)->False;
  (_)->True
});
  (_)->True
}));
  (return ((fst choose_break) ++ e ++ (snd choose_break)));
});
breaks::[](a)->[](([](a),[](a)));
breaks x = (tail((zip (inits x) (tails x))));
type Numbered  = (Block_element,Maybe(Int));
process_block_n::Int->Block->[](Numbered);
process_block_n n b = (case b of {
  ([])->[];
  ((:)(Endif) (rest))->((:) ((Endif ),(Nothing )) (process_block_n n rest));
  ((:)(Else) (rest))->((:) ((Else ),(Nothing )) (process_block_n n rest));
  ((:)(S(a)) (rest))->((:) ((S (a )),(Nothing )) (process_block_n n rest));
  ((:)(head) (rest))->((:) ((head ),(Just (n ))) (process_block_n ((+) 1 n) rest))
});
process_block = (process_block_n 1);
to_string_block_element::Numbered->String;
to_string_block_element s = ((case (fst s) of {
  (If)->"`ifdef";
  (If_not)->"`ifndef";
  (Else)->"`else";
  (Elsif)->"`elsif";
  (Endif)->"`endif";
  (S(n))->("placeholder" ++ (show n))
}) ++ (case (snd s) of {
  (Nothing)->"";
  (Just(i))->((++) " def" (show i))
}) ++ "\n");
insert_dummy_placeholders::Block->Block;
insert_dummy_placeholders b = ((:) (S 0) (double_post b (map S (enumFrom 1))));
double_list::a->a->[](a);
double_list x y = [x,y];
double_post::[](a)->[](a)->[](a);
double_post x y = (concat((map (uncurry double_list))((zip x y))));
is_numbered::Block_element->Bool;
is_numbered b = (case b of {
  (Else)->False;
  (Endif)->False;
  (_)->True
});
get_max_number::Block->Int;
get_max_number b = (length (filter is_numbered b));
subsets::[](a)->[]([](a));
subsets x = (case x of {
  ([])->[[]];
  ((:)(head) (tail))->(do{
  s<-(subsets tail);
  [((:) head s),s];
})
});
define_n::Int->String;
define_n n = ("`define def" ++ (show n) ++ "\n");
type Def_token  = Maybe(Int);
data  Statement  = Ifc(Bool)([]((Def_token,[](Statement))))([](Statement)) | Other(Block_element) deriving (Show);
type Rest  = [](Numbered);
type Stmts_Rest  = ([](Statement),Rest);
type Stmt_Rest  = (Statement,Rest);
parse::Rest->[](Statement);
parse l = (case (parse_until_else_or_endif l) of {
  ((s),([]))->s
});
ifdef_chain::Bool->Def_token->Rest->Stmt_Rest;
ifdef_chain is_positive d l = (let {
if_yes = (fst if_yes_calculate);
if_yes_calculate = (parse_until_else_or_endif l);
do_elseif_chain::Rest->([]((Def_token,[](Statement))),Rest);
do_elseif_chain l = (case l of {
  ((:)((Elsif),(d)) (rest1))->(let {
mypart_2 = (parse_until_else_or_endif rest1);
after_mypart = (snd mypart_2);
rest_elseif = (case after_mypart of {
  ((:)((Elsif),(_)) (rest))->(do_elseif_chain after_mypart);
  (_)->([],after_mypart)
})
}
 in (((:) (d,(fst mypart_2)) (fst rest_elseif)),(snd rest_elseif)))
});
if_yes_rest = (snd if_yes_calculate);
elseif_chain_calculate = (case if_yes_rest of {
  ([])->nothing;
  ((:)((Endif),(_)) (_))->([],if_yes_rest);
  ((:)((Else),(_)) (_))->([],if_yes_rest);
  ((:)((Elsif),(_)) (rest))->(do_elseif_chain if_yes_rest)
});
elseif_chain = (fst elseif_chain_calculate);
elseif_chain_rest = (snd elseif_chain_calculate);
elsepart_calculate = (case elseif_chain_rest of {
  ([])->nothing;
  ((:)((Endif),(_)) (rest))->([],rest);
  ((:)((Else),(_)) (rest))->(do_else rest)
});
do_else::Rest->([](Statement),Rest);
do_else l = (parse_until_endif l);
nothing = ([],[]);
elsepart = (fst elsepart_calculate);
rest = (snd elsepart_calculate)
}
 in ((Ifc is_positive ((:) (d,if_yes) elseif_chain) elsepart),rest));
parse_until_else_or_endif::Rest->Stmts_Rest;
parse_until_else_or_endif l = (case l of {
  ([])->([],[]);
  ((:)((Else),(_)) (_))->([],l);
  ((:)((Endif),(_)) (_))->([],l);
  ((:)((Elsif),(_)) (_))->([],l);
  ((:)((S(s)),(_)) (rest))->(let {
more::([](Statement),Rest);
more = (parse_until_else_or_endif rest)
}
 in (((:) (Other (S (s ))) (fst more)),(snd more)));
  ((:)((if_or_not),(tok)) (rest))->(let {
ifdef_result = (ifdef_chain (case if_or_not of {
  (If)->True;
  (If_not)->False
}) tok rest);
until = (parse_until_else_or_endif (snd ifdef_result))
}
 in ((((:) (fst ifdef_result) (fst until)),(snd until))))
});
parse_until_endif::Rest->Stmts_Rest;
parse_until_endif l = (case (parse_until_else_or_endif l) of {
  ((_),((:)((Else),(_)) (_)))->(error "Else unexpected");
  ((s),((:)((Endif),(_)) (rest)))->(s,rest);
  ((s),([]))->(s,[])
});
evaluate_one::Environment->Statement->IO(());
evaluate_one environment f = (case f of {
  (Ifc(positive) (chain) (elsec))->(follow_chain environment positive chain elsec);
  (Other(S(n)))->(do{
  (execute n True);
})
});
evaluate::Environment->[](Statement)->IO(());
evaluate environment l = (mapM_ (evaluate_one environment) l);
type If_branch  = (Def_token,[](Statement));
type If_branches  = [](If_branch);
follow_chain::Environment->Bool->If_branches->[](Statement)->IO(());
follow_chain environment positive l elsec = (case l of {
  ([])->(evaluate environment elsec);
  ((:)((def),(ll)) (rest))->(case ((==) positive (elem def environment)) of {
  (True)->(do{
  (evaluate environment ll);
  (mapM_ mark_ifc_False rest);
  (mark_block_False elsec);
});
  (False)->(do{
  (mark_block_False ll);
  (follow_chain environment True rest elsec);
})
})
});
mark_ifc_False::If_branch->IO(());
mark_ifc_False l = (mark_block_False (snd l));
execute::Int->Bool->IO(());
execute n dir = (putStrLn ("execution " ++ (show n) ++ " " ++ (show dir)));
mark_block_False::[](Statement)->IO(());
mark_block_False s = (mapM_ mark_it_False s);
mark_it_False::Statement->IO(());
mark_it_False s = (case s of {
  (Other(S(n)))->(execute n False);
  (Ifc(_) (chain) (elsec))->(do{
  (mapM_ mark_ifc_False chain);
  (mark_block_False elsec);
})
});
type Environment  = [](Def_token);
perly_output_single::Block->[](Int)->IO(());
perly_output_single b defs = (let {
dummied_block = (process_block(insert_dummy_placeholders(b)))
}
 in (do{
  ((mapM_ putStr)((map define_n)(defs)));
  (putStr((concatMap to_string_block_element)(dummied_block)));
  ((evaluate (map Just defs))(parse(dummied_block)));
  (putStrLn "====");
}));
perly_many_defs::Block->IO(());
perly_many_defs b = (mapM_ (perly_output_single b) (subsets (enumFromTo 1 (get_max_number b))));
run6::IO(());
run6 = (perly_many_defs ((!!) block_types 6));
runall::IO(());
runall = (mapM_ perly_many_defs ((++) embeds (concatMap try_embed embeds)))
}