{-# LANGUAGE DeriveGeneric #-}
{-# OPTIONS_GHC -fno-warn-unused-imports #-}

-- UUAGC 0.9.55 (src/GLua/AG/PrettyPrint.ag)
module GLua.AG.PrettyPrint where

{-# LINE 10 "src/GLua/AG/AST.ag" #-}

import Data.Aeson
import GHC.Generics
import GLua.AG.Token
import GLua.TokenTypes ()
{-# LINE 15 "src/GLua/AG/PrettyPrint.hs" #-}

{-# LINE 4 "src/GLua/AG/PrettyPrint.ag" #-}

import Data.List (foldl', isInfixOf)
import Data.Maybe
import Debug.Trace
import GLua.AG.AST
import GLua.TokenTypes
import Text.Parsec
import Text.Parsec.Error
import Text.ParserCombinators.UU.BasicInstances hiding (pos)
import Text.PrettyPrint hiding (braces, brackets, parens)
import Prelude hiding ((<>))
{-# LINE 29 "src/GLua/AG/PrettyPrint.hs" #-}
{-# LINE 19 "src/GLua/AG/PrettyPrint.ag" #-}

tok :: MToken -> Doc
tok (MToken _ t) = zeroWidthText . show $ t

printList :: (a -> Doc) -> String -> [a] -> Doc
printList _ _ [] = empty
printList f sep' (e : es) = (f e) <> g es
  where
    g [] = empty
    g (e' : es') = zeroWidthText sep' <> (f e') <> g es'

data IsEmpty = IsEmpty | NonEmpty

fromEmpty :: IsEmpty -> Bool
fromEmpty IsEmpty = True
fromEmpty NonEmpty = False

toEmpty :: Bool -> IsEmpty
toEmpty b = if b then IsEmpty else NonEmpty

data PrettyPrintConfig = PPConfig
  { spaceAfterParens :: Bool
  , spaceAfterBrackets :: Bool
  , spaceAfterBraces :: Bool
  , spaceEmptyParens :: Bool
  , spaceEmptyBraces :: Bool
  , spaceAfterLabel :: Bool
  , spaceBeforeComma :: Bool
  , spaceAfterComma :: Bool
  , semicolons :: Bool
  , cStyle :: Bool
  , removeRedundantParens :: Bool
  , minimizeParens :: Bool
  , assumeOperatorAssociativity :: Bool
  , indentation :: String
  }

defaultPPConfig :: PrettyPrintConfig
defaultPPConfig =
  PPConfig
    { spaceAfterParens = False
    , spaceAfterBrackets = False
    , spaceAfterBraces = False
    , spaceEmptyParens = False
    , spaceEmptyBraces = False
    , spaceAfterLabel = False
    , spaceBeforeComma = False
    , spaceAfterComma = True
    , semicolons = False
    , cStyle = False
    , removeRedundantParens = True
    , assumeOperatorAssociativity = True
    , minimizeParens = False
    , indentation = "    "
    }

metaDoc :: Maybe MToken -> Doc
metaDoc (Just m) = zchr ':' <> tok m
metaDoc Nothing = empty

printVarList :: [(PrefixExp, Maybe MExpr)] -> Doc
printVarList vars =
  printList pp_prefixexp ", " (map fst vars)
    <-> zchr '='
    <-> printList pp_mexpr ", " (catMaybes . map snd $ vars)

printStats :: [MStat] -> Int -> Doc
printStats [] _ = empty
printStats (x : xs) i = nest (i * 4) (pp_mstat x i) $+$ printStats xs i

printElIfs :: [(MExpr, Block)] -> Int -> Doc
printElIfs [] _ = empty
printElIfs ((e, b) : es) i =
  zeroWidthText "elseif"
    <-> pp_mexpr e
    <-> zeroWidthText "then"
    $+$ pp_block b i
    $+$ printElIfs es i

printEls :: Maybe Block -> Int -> Doc
printEls Nothing _ = empty
printEls (Just b) i = zeroWidthText "else" $+$ pp_block b i

renderPos :: LineColPos -> String
renderPos (LineColPos l c _) = "line " ++ show (succ l) ++ ", column " ++ show (succ c)

renderRegion :: Region -> String
renderRegion (Region l r) = renderPos l ++ " - " ++ renderPos r

renderSourcePos :: SourcePos -> String
renderSourcePos sp =
  "line "
    ++ (show . succ . sourceLine $ sp)
    ++ ", column "
    ++ (show . succ . sourceColumn $ sp)

getMStatPos :: MStat -> String
getMStatPos (MStat p _) = renderRegion p

getAReturnPos :: AReturn -> String
getAReturnPos (AReturn p _) = renderRegion p
getAReturnPos NoReturn = "<unknown>"

getMExprPos :: MExpr -> String
getMExprPos (MExpr p _) = renderRegion p

renderError :: Error LineColPos -> String
renderError (Inserted str pos strs) =
  renderPos pos
    ++ ": Inserted '"
    ++ str
    ++ "'."
    ++ render_expecting strs
renderError (Deleted str pos strs) =
  renderPos pos
    ++ ": Removed '"
    ++ str
    ++ "'. "
    ++ render_expecting strs
renderError (Replaced str1 str2 pos strs) =
  renderPos pos
    ++ ": Replaced '"
    ++ str1
    ++ "' with '"
    ++ str2
    ++ "' at "
    ++ renderPos pos
    ++ render_expecting strs
renderError (DeletedAtEnd str) =
  "Deleted '"
    ++ str
    ++ "' at the end of the Lua file because the parser doesn't know what to do with it."

render_expecting :: [String] -> String
render_expecting [a] = "Parser expected a " ++ a
render_expecting (a : as) = "Parser expected one of [" ++ a ++ concat (map (", " ++) as) ++ "]"
render_expecting [] = "Parser expected nothing"

renderPSError :: ParseError -> String
renderPSError ps =
  map replNL
    . showErrorMessages
      "or"
      "unknown parse error"
      "expecting"
      "unexpected"
      "end of input"
    . errorMessages
    $ ps
  where
    replNL '\n' = ' '
    replNL c = c

-- | Render comments on multiple lines
renderMLComments :: PrettyPrintConfig -> Int -> [MToken] -> Doc
renderMLComments conf ind toks =
  foldl' ($+$) empty . map (indent conf ind . tok . convertComment conf) $ toks

-- | Render comments, and prefer having them on a single line. It may not print comments on the same
-- line if that would cause a syntax error (e.g. a multiline comment after a single line comment)
renderSLComments :: PrettyPrintConfig -> Int -> [MToken] -> Doc
renderSLComments conf ind toks = foldl' combine empty . map (convertComment conf) $ toks
  where
    combine :: Doc -> MToken -> Doc
    combine acc mt@(MToken _pos t) =
      case t of
        -- Block comments after single line comments cannot be printed on the same line, as that
        -- would cause a syntax error, e.g. in this case:

        -- foo = { -- single line comment
        -- --[[multiline
        -- comment
        -- ]]
        -- }
        -- Make sure in these cases the comment is printed on a new line, rather than on the
        -- same line
        DashBlockComment _depth comment
          | '\n' `elem` comment ->
              acc $+$ (indent conf ind $ tok mt)
        SlashBlockComment comment
          | '\n' `elem` comment ->
              acc $+$ (indent conf ind $ tok mt)
        _ -> acc <-> tok mt

convertComment :: PrettyPrintConfig -> MToken -> MToken
convertComment conf (MToken p t) = MToken p $ convert' t
  where
    convert' :: Token -> Token
    convert' = if cStyle conf then cComment else luaComment

    luaComment :: Token -> Token
    luaComment (SlashComment s) = DashComment s
    luaComment (SlashBlockComment s) = DashBlockComment (lastBracket s) s
    luaComment t' = t'

    -- converting /*]*/ would end up in --[[]]] when plainly converted
    -- Deepen the block comment by 1 if that's the case
    lastBracket :: String -> Int
    lastBracket [] = 0
    lastBracket s = if last s == ']' then 1 else 0

    cComment :: Token -> Token
    cComment (DashComment s) = SlashComment s
    cComment (DashBlockComment _ s) = SlashBlockComment s
    cComment t' = t'

indent :: PrettyPrintConfig -> Int -> Doc -> Doc
indent conf n = (<>) $ zeroWidthText (concat . replicate n $ indentation conf)

parens :: PrettyPrintConfig -> IsEmpty -> Doc -> Doc
parens conf ie doc = zchr '(' `sep'` doc `sep'` zchr ')'
  where
    sep' :: Doc -> Doc -> Doc
    sep' =
      if spaceAfterParens conf && (not (fromEmpty ie) || spaceEmptyParens conf)
        then (<->)
        else (<>)

brackets :: PrettyPrintConfig -> Doc -> Doc
brackets conf doc = zchr '[' `sep'` doc `sep'` zchr ']'
  where
    sep' :: Doc -> Doc -> Doc
    sep' = if spaceAfterBrackets conf then (<->) else (<>)

braces :: PrettyPrintConfig -> IsEmpty -> Doc -> Doc
braces conf ie doc = zchr '{' `sep'` doc `sep'` zchr '}'
  where
    sep' :: Doc -> Doc -> Doc
    sep' =
      if spaceAfterBraces conf && (not (fromEmpty ie) || spaceEmptyBraces conf)
        then (<->)
        else (<>)

-- Zero width char
zchr :: Char -> Doc
zchr c = zeroWidthText [c]

-- Zero width <+>
infixl 6 <->
(<->) :: Doc -> Doc -> Doc
a <-> b
  | a == empty = b
  | b == empty = a
  | otherwise = a <> zchr ' ' <> b

-- Operator levels, where level 1 is the lowest level, and level 8 is the highest one
-- See http://www.lua.org/manual/5.2/manual.html#3.4.7
data OperatorLevel
  = -- At the top level, there is no assigned operator level yet. This serves as a bottom value.
    TopLevelExpression
  | OperatorLevel1
  | OperatorLevel2
  | OperatorLevel3
  | OperatorLevel4
  | OperatorLevel5
  | OperatorLevel6
  | OperatorLevel7
  | OperatorLevel8
  deriving (Eq, Ord)

-- | Returns true when any of the comments contain the string "format: multiline"
commentsForceMultiline :: [MToken] -> Bool
commentsForceMultiline commentTokens = any containsFormatMultiline commentTokens
  where
    containsFormatMultiline :: MToken -> Bool
    containsFormatMultiline (MToken _pos t) = case t of
      DashComment comment -> stringForcesFormat comment
      DashBlockComment _ comment -> stringForcesFormat comment
      SlashComment comment -> stringForcesFormat comment
      SlashBlockComment comment -> stringForcesFormat comment
      _ -> False

    stringForcesFormat :: String -> Bool
    stringForcesFormat s = "format: multiline" `isInfixOf` s

{-# LINE 304 "src/GLua/AG/PrettyPrint.hs" #-}

{-# LINE 1235 "src/GLua/AG/PrettyPrint.ag" #-}

pp_block :: Block -> Int -> Doc
pp_block p i = pretty_Syn_Block (wrap_Block (sem_Block p) (emptyInh_Block{indent_Inh_Block = i}))

pp_mstat :: MStat -> Int -> Doc
pp_mstat p i = pretty_Syn_MStat (wrap_MStat (sem_MStat p) emptyInh_MStat{indent_Inh_MStat = i})

pp_prefixexp :: PrefixExp -> Doc
pp_prefixexp p = pretty_Syn_PrefixExp (wrap_PrefixExp (sem_PrefixExp p) emptyInh_PrefixExp)

pp_pfexprsuffix :: PFExprSuffix -> Doc
pp_pfexprsuffix p =
  pretty_Syn_PFExprSuffix (wrap_PFExprSuffix (sem_PFExprSuffix p) emptyInh_PFExprSuffix)

pp_field :: Field -> Doc
pp_field p = pretty_Syn_Field (wrap_Field (sem_Field p) emptyInh_Field)

pp_mexpr :: MExpr -> Doc
pp_mexpr p = pretty_Syn_MExpr (wrap_MExpr (sem_MExpr p) emptyInh_MExpr)

prettyprint :: AST -> String
prettyprint p = render $ pretty_Syn_AST (wrap_AST (sem_AST p) emptyInh_AST)

prettyprintConf :: PrettyPrintConfig -> AST -> String
prettyprintConf conf p =
  render $ pretty_Syn_AST (wrap_AST (sem_AST p) emptyInh_AST{ppconf_Inh_AST = conf})

renderBlock :: Block -> String
renderBlock p = render $ pretty_Syn_Block (wrap_Block (sem_Block p) emptyInh_Block)

renderStat :: Stat -> String
renderStat p = render $ pretty_Syn_Stat (wrap_Stat (sem_Stat p) emptyInh_Stat)

renderMStat :: MStat -> String
renderMStat p = render $ pretty_Syn_MStat (wrap_MStat (sem_MStat p) emptyInh_MStat)

renderAReturn :: AReturn -> String
renderAReturn p = render $ pretty_Syn_AReturn (wrap_AReturn (sem_AReturn p) emptyInh_AReturn)

renderFuncName :: FuncName -> String
renderFuncName p = render $ pretty_Syn_FuncName (wrap_FuncName (sem_FuncName p) emptyInh_FuncName)

renderPrefixExp :: PrefixExp -> String
renderPrefixExp p =
  render $ pretty_Syn_PrefixExp (wrap_PrefixExp (sem_PrefixExp p) emptyInh_PrefixExp)

renderExpr :: Expr -> String
renderExpr p = render $ pretty_Syn_Expr (wrap_Expr (sem_Expr p) emptyInh_Expr)

renderMExpr :: MExpr -> String
renderMExpr p = render $ pretty_Syn_MExpr (wrap_MExpr (sem_MExpr p) emptyInh_MExpr)

renderArgs :: Args -> String
renderArgs p = render $ pretty_Syn_Args (wrap_Args (sem_Args p) emptyInh_Args)

renderField :: Field -> String
renderField p = render $ pretty_Syn_Field (wrap_Field (sem_Field p) emptyInh_Field)

emptyInh_Field :: Inh_Field
emptyInh_Field =
  Inh_Field
    { comments_Inh_Field = []
    , forceMultiline_Inh_Field = False
    , indent_Inh_Field = 0
    , ppconf_Inh_Field = defaultPPConfig
    }

emptyInh_Args :: Inh_Args
emptyInh_Args =
  Inh_Args
    { comments_Inh_Args = []
    , forceMultiline_Inh_Args = False
    , indent_Inh_Args = 0
    , ppconf_Inh_Args = defaultPPConfig
    }

emptyInh_MExpr :: Inh_MExpr
emptyInh_MExpr =
  Inh_MExpr
    { comments_Inh_MExpr = []
    , forceMultiline_Inh_MExpr = False
    , indent_Inh_MExpr = 0
    , parentOperatorAssociative_Inh_MExpr = True
    , parentOperatorPrecedence_Inh_MExpr = TopLevelExpression
    , ppconf_Inh_MExpr = defaultPPConfig
    }

emptyInh_Expr :: Inh_Expr
emptyInh_Expr =
  Inh_Expr
    { comments_Inh_Expr = []
    , forceMultiline_Inh_Expr = False
    , indent_Inh_Expr = 0
    , parentOperatorAssociative_Inh_Expr = True
    , parentOperatorPrecedence_Inh_Expr = TopLevelExpression
    , ppconf_Inh_Expr = defaultPPConfig
    , statRegion_Inh_Expr = emptyRg
    }

emptyInh_PrefixExp :: Inh_PrefixExp
emptyInh_PrefixExp =
  Inh_PrefixExp
    { comments_Inh_PrefixExp = []
    , forceMultiline_Inh_PrefixExp = False
    , indent_Inh_PrefixExp = 0
    , parentOperatorAssociative_Inh_PrefixExp = True
    , parentOperatorPrecedence_Inh_PrefixExp = TopLevelExpression
    , ppconf_Inh_PrefixExp = defaultPPConfig
    }

emptyInh_FuncName :: Inh_FuncName
emptyInh_FuncName =
  Inh_FuncName
    { comments_Inh_FuncName = []
    , indent_Inh_FuncName = 0
    , ppconf_Inh_FuncName = defaultPPConfig
    }

emptyInh_AReturn :: Inh_AReturn
emptyInh_AReturn =
  Inh_AReturn
    { comments_Inh_AReturn = []
    , forceMultiline_Inh_AReturn = False
    , indent_Inh_AReturn = 0
    , ppconf_Inh_AReturn = defaultPPConfig
    }

emptyInh_MStat :: Inh_MStat
emptyInh_MStat =
  Inh_MStat
    { comments_Inh_MStat = []
    , forceMultiline_Inh_MStat = False
    , indent_Inh_MStat = 0
    , isLastStatement_Inh_MStat = False
    , ppconf_Inh_MStat = defaultPPConfig
    , wouldBeAmbiguousWithoutSemicolon_Inh_MStat = False
    }

emptyInh_Stat :: Inh_Stat
emptyInh_Stat =
  Inh_Stat
    { comments_Inh_Stat = []
    , forceMultiline_Inh_Stat = False
    , indent_Inh_Stat = 0
    , isLastStatement_Inh_Stat = False
    , ppconf_Inh_Stat = defaultPPConfig
    , statRegion_Inh_Stat = emptyRg
    , wouldBeAmbiguousWithoutSemicolon_Inh_Stat = False
    }

emptyInh_Block :: Inh_Block
emptyInh_Block =
  Inh_Block
    { comments_Inh_Block = []
    , forceMultiline_Inh_Block = False
    , indent_Inh_Block = 0
    , ppconf_Inh_Block = defaultPPConfig
    , statRegion_Inh_Block = emptyRg
    }

emptyInh_AST :: Inh_AST
emptyInh_AST =
  Inh_AST
    { indent_Inh_AST = 0
    , ppconf_Inh_AST = defaultPPConfig
    }

emptyInh_PFExprSuffix :: Inh_PFExprSuffix
emptyInh_PFExprSuffix =
  Inh_PFExprSuffix
    { comments_Inh_PFExprSuffix = []
    , forceMultiline_Inh_PFExprSuffix = False
    , indent_Inh_PFExprSuffix = 0
    , ppconf_Inh_PFExprSuffix = defaultPPConfig
    }

{-# LINE 484 "src/GLua/AG/PrettyPrint.hs" #-}
-- AReturn -----------------------------------------------------
-- cata
sem_AReturn
  :: AReturn
  -> T_AReturn
sem_AReturn (AReturn _pos _values) =
  (sem_AReturn_AReturn _pos (sem_MExprList _values))
sem_AReturn (NoReturn) =
  (sem_AReturn_NoReturn)

-- semantic domain
type T_AReturn =
  ([MToken])
  -> Bool
  -> Int
  -> PrettyPrintConfig
  -> (([MToken]), AReturn, Bool, Doc, Int)
data Inh_AReturn = Inh_AReturn {comments_Inh_AReturn :: ([MToken]), forceMultiline_Inh_AReturn :: Bool, indent_Inh_AReturn :: Int, ppconf_Inh_AReturn :: PrettyPrintConfig}
data Syn_AReturn = Syn_AReturn {comments_Syn_AReturn :: ([MToken]), copy_Syn_AReturn :: AReturn, isMultiline_Syn_AReturn :: Bool, pretty_Syn_AReturn :: Doc, statementCount_Syn_AReturn :: Int}
wrap_AReturn
  :: T_AReturn
  -> Inh_AReturn
  -> Syn_AReturn
wrap_AReturn sem (Inh_AReturn _lhsIcomments _lhsIforceMultiline _lhsIindent _lhsIppconf) =
  ( let
      (_lhsOcomments, _lhsOcopy, _lhsOisMultiline, _lhsOpretty, _lhsOstatementCount) = sem _lhsIcomments _lhsIforceMultiline _lhsIindent _lhsIppconf
    in
      (Syn_AReturn _lhsOcomments _lhsOcopy _lhsOisMultiline _lhsOpretty _lhsOstatementCount)
  )
sem_AReturn_AReturn
  :: Region
  -> T_MExprList
  -> T_AReturn
sem_AReturn_AReturn pos_ values_ =
  ( \_lhsIcomments
     _lhsIforceMultiline
     _lhsIindent
     _lhsIppconf ->
        ( let
            _lhsOpretty :: Doc
            _lhsOisMultiline :: Bool
            _valuesOcomments :: ([MToken])
            _lhsOcomments :: ([MToken])
            _valuesOforceMultiline :: Bool
            _valuesOsomeElementsInListAreMultiline :: Bool
            _lhsOstatementCount :: Int
            _lhsOcopy :: AReturn
            _valuesOindent :: Int
            _valuesOppconf :: PrettyPrintConfig
            _valuesIcomments :: ([MToken])
            _valuesIcopy :: MExprList
            _valuesIisAssociative :: Bool
            _valuesIisLast :: Bool
            _valuesIisMultiline :: Bool
            _valuesIpos :: Region
            _valuesIprecedence :: OperatorLevel
            _valuesIpretty :: Doc
            _lhsOpretty =
              ( renderMLComments _lhsIppconf _lhsIindent (fst _commentsBefore)
                  $+$ indent _lhsIppconf _lhsIindent (zeroWidthText "return")
                    <-> _valuesIpretty
                    <> _semicolon
                      <-> renderSLComments _lhsIppconf _lhsIindent (fst _commentsAfter)
              )
            _lhsOisMultiline =
              ( _valuesIisMultiline
                  || not (null $ fst _commentsBefore)
                  || not (null $ fst _commentsAfter)
              )
            _semicolon =
              ( if semicolons _lhsIppconf then zchr ';' else empty
              )
            _commentsBefore =
              ( span (\(MToken pos _) -> pos `before` pos_) _lhsIcomments
              )
            _valuesOcomments =
              ( snd _commentsBefore
              )
            _commentsAfter =
              ( span (\(MToken pos _) -> pos `beforeOrOnLine` (rgOr _valuesIpos pos_)) _valuesIcomments
              )
            _lhsOcomments =
              ( snd _commentsAfter
              )
            _valuesOforceMultiline =
              ( False
              )
            _valuesOsomeElementsInListAreMultiline =
              ( False
              )
            _lhsOstatementCount =
              ( 1
              )
            _copy =
              ( AReturn pos_ _valuesIcopy
              )
            _lhsOcopy =
              ( _copy
              )
            _valuesOindent =
              ( _lhsIindent
              )
            _valuesOppconf =
              ( _lhsIppconf
              )
            (_valuesIcomments, _valuesIcopy, _valuesIisAssociative, _valuesIisLast, _valuesIisMultiline, _valuesIpos, _valuesIprecedence, _valuesIpretty) =
              values_ _valuesOcomments _valuesOforceMultiline _valuesOindent _valuesOppconf _valuesOsomeElementsInListAreMultiline
          in
            (_lhsOcomments, _lhsOcopy, _lhsOisMultiline, _lhsOpretty, _lhsOstatementCount)
        )
  )
sem_AReturn_NoReturn :: T_AReturn
sem_AReturn_NoReturn =
  ( \_lhsIcomments
     _lhsIforceMultiline
     _lhsIindent
     _lhsIppconf ->
        ( let
            _lhsOpretty :: Doc
            _lhsOstatementCount :: Int
            _lhsOisMultiline :: Bool
            _lhsOcopy :: AReturn
            _lhsOcomments :: ([MToken])
            _lhsOpretty =
              ( empty
              )
            _lhsOstatementCount =
              ( 0
              )
            _lhsOisMultiline =
              ( False
              )
            _copy =
              ( NoReturn
              )
            _lhsOcopy =
              ( _copy
              )
            _lhsOcomments =
              ( _lhsIcomments
              )
          in
            (_lhsOcomments, _lhsOcopy, _lhsOisMultiline, _lhsOpretty, _lhsOstatementCount)
        )
  )

-- AST ---------------------------------------------------------
-- cata
sem_AST
  :: AST
  -> T_AST
sem_AST (AST _comments _chunk) =
  (sem_AST_AST _comments (sem_Block _chunk))

-- semantic domain
type T_AST =
  Int
  -> PrettyPrintConfig
  -> (AST, Bool, Doc)
data Inh_AST = Inh_AST {indent_Inh_AST :: Int, ppconf_Inh_AST :: PrettyPrintConfig}
data Syn_AST = Syn_AST {copy_Syn_AST :: AST, isMultiline_Syn_AST :: Bool, pretty_Syn_AST :: Doc}
wrap_AST
  :: T_AST
  -> Inh_AST
  -> Syn_AST
wrap_AST sem (Inh_AST _lhsIindent _lhsIppconf) =
  ( let
      (_lhsOcopy, _lhsOisMultiline, _lhsOpretty) = sem _lhsIindent _lhsIppconf
    in
      (Syn_AST _lhsOcopy _lhsOisMultiline _lhsOpretty)
  )
sem_AST_AST
  :: ([MToken])
  -> T_Block
  -> T_AST
sem_AST_AST comments_ chunk_ =
  ( \_lhsIindent
     _lhsIppconf ->
        ( let
            _lhsOpretty :: Doc
            _lhsOisMultiline :: Bool
            _chunkOcomments :: ([MToken])
            _chunkOstatRegion :: Region
            _chunkOforceMultiline :: Bool
            _lhsOcopy :: AST
            _chunkOindent :: Int
            _chunkOppconf :: PrettyPrintConfig
            _chunkIcomments :: ([MToken])
            _chunkIcopy :: Block
            _chunkIisMultiline :: Bool
            _chunkIpretty :: Doc
            _chunkIstatementCount :: Int
            _lhsOpretty =
              ( _chunkIpretty $+$ _prettyComments
              )
            _lhsOisMultiline =
              ( _chunkIisMultiline
              )
            _prettyComments =
              ( renderMLComments _lhsIppconf _lhsIindent _chunkIcomments
              )
            _chunkOcomments =
              ( comments_
              )
            _chunkOstatRegion =
              ( emptyRg
              )
            _chunkOforceMultiline =
              ( False
              )
            _copy =
              ( AST comments_ _chunkIcopy
              )
            _lhsOcopy =
              ( _copy
              )
            _chunkOindent =
              ( _lhsIindent
              )
            _chunkOppconf =
              ( _lhsIppconf
              )
            (_chunkIcomments, _chunkIcopy, _chunkIisMultiline, _chunkIpretty, _chunkIstatementCount) =
              chunk_ _chunkOcomments _chunkOforceMultiline _chunkOindent _chunkOppconf _chunkOstatRegion
          in
            (_lhsOcopy, _lhsOisMultiline, _lhsOpretty)
        )
  )

-- Args --------------------------------------------------------
-- cata
sem_Args
  :: Args
  -> T_Args
sem_Args (ListArgs _args) =
  (sem_Args_ListArgs (sem_MExprList _args))
sem_Args (TableArg _arg) =
  (sem_Args_TableArg (sem_FieldList _arg))
sem_Args (StringArg _arg) =
  (sem_Args_StringArg _arg)

-- semantic domain
type T_Args =
  ([MToken])
  -> Bool
  -> Int
  -> PrettyPrintConfig
  -> (([MToken]), Args, Bool, Doc)
data Inh_Args = Inh_Args {comments_Inh_Args :: ([MToken]), forceMultiline_Inh_Args :: Bool, indent_Inh_Args :: Int, ppconf_Inh_Args :: PrettyPrintConfig}
data Syn_Args = Syn_Args {comments_Syn_Args :: ([MToken]), copy_Syn_Args :: Args, isMultiline_Syn_Args :: Bool, pretty_Syn_Args :: Doc}
wrap_Args
  :: T_Args
  -> Inh_Args
  -> Syn_Args
wrap_Args sem (Inh_Args _lhsIcomments _lhsIforceMultiline _lhsIindent _lhsIppconf) =
  ( let
      (_lhsOcomments, _lhsOcopy, _lhsOisMultiline, _lhsOpretty) = sem _lhsIcomments _lhsIforceMultiline _lhsIindent _lhsIppconf
    in
      (Syn_Args _lhsOcomments _lhsOcopy _lhsOisMultiline _lhsOpretty)
  )
sem_Args_ListArgs
  :: T_MExprList
  -> T_Args
sem_Args_ListArgs args_ =
  ( \_lhsIcomments
     _lhsIforceMultiline
     _lhsIindent
     _lhsIppconf ->
        ( let
            _lhsOpretty :: Doc
            _lhsOisMultiline :: Bool
            _argsOindent :: Int
            _argsOsomeElementsInListAreMultiline :: Bool
            _lhsOcopy :: Args
            _lhsOcomments :: ([MToken])
            _argsOcomments :: ([MToken])
            _argsOforceMultiline :: Bool
            _argsOppconf :: PrettyPrintConfig
            _argsIcomments :: ([MToken])
            _argsIcopy :: MExprList
            _argsIisAssociative :: Bool
            _argsIisLast :: Bool
            _argsIisMultiline :: Bool
            _argsIpos :: Region
            _argsIprecedence :: OperatorLevel
            _argsIpretty :: Doc
            _lhsOpretty =
              ( if _argsIisMultiline
                  then
                    zchr '('
                      $+$ _argsIpretty
                      $+$ indent _lhsIppconf _lhsIindent (zchr ')')
                  else parens _lhsIppconf _emptyParams _argsIpretty
              )
            _lhsOisMultiline =
              ( _argsIisMultiline
              )
            _emptyParams =
              ( toEmpty $ null _argsIcopy
              )
            _argsOindent =
              ( if _argsIisMultiline then _lhsIindent + 1 else 0
              )
            _argsOsomeElementsInListAreMultiline =
              ( False
              )
            _copy =
              ( ListArgs _argsIcopy
              )
            _lhsOcopy =
              ( _copy
              )
            _lhsOcomments =
              ( _argsIcomments
              )
            _argsOcomments =
              ( _lhsIcomments
              )
            _argsOforceMultiline =
              ( _lhsIforceMultiline
              )
            _argsOppconf =
              ( _lhsIppconf
              )
            (_argsIcomments, _argsIcopy, _argsIisAssociative, _argsIisLast, _argsIisMultiline, _argsIpos, _argsIprecedence, _argsIpretty) =
              args_ _argsOcomments _argsOforceMultiline _argsOindent _argsOppconf _argsOsomeElementsInListAreMultiline
          in
            (_lhsOcomments, _lhsOcopy, _lhsOisMultiline, _lhsOpretty)
        )
  )
sem_Args_TableArg
  :: T_FieldList
  -> T_Args
sem_Args_TableArg arg_ =
  ( \_lhsIcomments
     _lhsIforceMultiline
     _lhsIindent
     _lhsIppconf ->
        ( let
            _lhsOpretty :: Doc
            _lhsOisMultiline :: Bool
            _argOindent :: Int
            _argOsomeElementsInListAreMultiline :: Bool
            _lhsOcopy :: Args
            _lhsOcomments :: ([MToken])
            _argOcomments :: ([MToken])
            _argOforceMultiline :: Bool
            _argOppconf :: PrettyPrintConfig
            _argIcomments :: ([MToken])
            _argIcopy :: FieldList
            _argIisMultiline :: Bool
            _argIisNil :: Bool
            _argIpretty :: Doc
            _lhsOpretty =
              ( if _argIisMultiline then _prettyMulti else _prettySingle
              )
            _lhsOisMultiline =
              ( _argIisMultiline
              )
            _prettyMulti =
              ( zchr '{' $+$ _argIpretty $+$ indent _lhsIppconf _lhsIindent (zchr '}')
              )
            _prettySingle =
              ( braces _lhsIppconf _emptyContents _argIpretty
              )
            _emptyContents =
              ( toEmpty $ null _argIcopy
              )
            _argOindent =
              ( _lhsIindent + (if _argIisMultiline then 1 else 0)
              )
            _argOsomeElementsInListAreMultiline =
              ( False
              )
            _copy =
              ( TableArg _argIcopy
              )
            _lhsOcopy =
              ( _copy
              )
            _lhsOcomments =
              ( _argIcomments
              )
            _argOcomments =
              ( _lhsIcomments
              )
            _argOforceMultiline =
              ( _lhsIforceMultiline
              )
            _argOppconf =
              ( _lhsIppconf
              )
            (_argIcomments, _argIcopy, _argIisMultiline, _argIisNil, _argIpretty) =
              arg_ _argOcomments _argOforceMultiline _argOindent _argOppconf _argOsomeElementsInListAreMultiline
          in
            (_lhsOcomments, _lhsOcopy, _lhsOisMultiline, _lhsOpretty)
        )
  )
sem_Args_StringArg
  :: MToken
  -> T_Args
sem_Args_StringArg arg_ =
  ( \_lhsIcomments
     _lhsIforceMultiline
     _lhsIindent
     _lhsIppconf ->
        ( let
            _lhsOpretty :: Doc
            _lhsOisMultiline :: Bool
            _lhsOcopy :: Args
            _lhsOcomments :: ([MToken])
            _lhsOpretty =
              ( tok arg_
              )
            _lhsOisMultiline =
              ( False
              )
            _copy =
              ( StringArg arg_
              )
            _lhsOcopy =
              ( _copy
              )
            _lhsOcomments =
              ( _lhsIcomments
              )
          in
            (_lhsOcomments, _lhsOcopy, _lhsOisMultiline, _lhsOpretty)
        )
  )

-- BinOp -------------------------------------------------------
-- cata
sem_BinOp
  :: BinOp
  -> T_BinOp
sem_BinOp (AOr) =
  (sem_BinOp_AOr)
sem_BinOp (AAnd) =
  (sem_BinOp_AAnd)
sem_BinOp (ALT) =
  (sem_BinOp_ALT)
sem_BinOp (AGT) =
  (sem_BinOp_AGT)
sem_BinOp (ALEQ) =
  (sem_BinOp_ALEQ)
sem_BinOp (AGEQ) =
  (sem_BinOp_AGEQ)
sem_BinOp (ANEq) =
  (sem_BinOp_ANEq)
sem_BinOp (AEq) =
  (sem_BinOp_AEq)
sem_BinOp (AConcatenate) =
  (sem_BinOp_AConcatenate)
sem_BinOp (APlus) =
  (sem_BinOp_APlus)
sem_BinOp (BinMinus) =
  (sem_BinOp_BinMinus)
sem_BinOp (AMultiply) =
  (sem_BinOp_AMultiply)
sem_BinOp (ADivide) =
  (sem_BinOp_ADivide)
sem_BinOp (AModulus) =
  (sem_BinOp_AModulus)
sem_BinOp (APower) =
  (sem_BinOp_APower)

-- semantic domain
type T_BinOp =
  ([MToken])
  -> Int
  -> PrettyPrintConfig
  -> (([MToken]), BinOp, Bool, Bool, OperatorLevel, Doc)
data Inh_BinOp = Inh_BinOp {comments_Inh_BinOp :: ([MToken]), indent_Inh_BinOp :: Int, ppconf_Inh_BinOp :: PrettyPrintConfig}
data Syn_BinOp = Syn_BinOp {comments_Syn_BinOp :: ([MToken]), copy_Syn_BinOp :: BinOp, isAssociative_Syn_BinOp :: Bool, isMultiline_Syn_BinOp :: Bool, precedence_Syn_BinOp :: OperatorLevel, pretty_Syn_BinOp :: Doc}
wrap_BinOp
  :: T_BinOp
  -> Inh_BinOp
  -> Syn_BinOp
wrap_BinOp sem (Inh_BinOp _lhsIcomments _lhsIindent _lhsIppconf) =
  ( let
      (_lhsOcomments, _lhsOcopy, _lhsOisAssociative, _lhsOisMultiline, _lhsOprecedence, _lhsOpretty) = sem _lhsIcomments _lhsIindent _lhsIppconf
    in
      (Syn_BinOp _lhsOcomments _lhsOcopy _lhsOisAssociative _lhsOisMultiline _lhsOprecedence _lhsOpretty)
  )
sem_BinOp_AOr :: T_BinOp
sem_BinOp_AOr =
  ( \_lhsIcomments
     _lhsIindent
     _lhsIppconf ->
        ( let
            _lhsOpretty :: Doc
            _lhsOisMultiline :: Bool
            _lhsOprecedence :: OperatorLevel
            _lhsOisAssociative :: Bool
            _lhsOcopy :: BinOp
            _lhsOcomments :: ([MToken])
            _lhsOpretty =
              ( zeroWidthText (if cStyle _lhsIppconf then "||" else "or")
              )
            _lhsOisMultiline =
              ( False
              )
            _lhsOprecedence =
              ( OperatorLevel1
              )
            _lhsOisAssociative =
              ( True
              )
            _copy =
              ( AOr
              )
            _lhsOcopy =
              ( _copy
              )
            _lhsOcomments =
              ( _lhsIcomments
              )
          in
            (_lhsOcomments, _lhsOcopy, _lhsOisAssociative, _lhsOisMultiline, _lhsOprecedence, _lhsOpretty)
        )
  )
sem_BinOp_AAnd :: T_BinOp
sem_BinOp_AAnd =
  ( \_lhsIcomments
     _lhsIindent
     _lhsIppconf ->
        ( let
            _lhsOpretty :: Doc
            _lhsOisMultiline :: Bool
            _lhsOprecedence :: OperatorLevel
            _lhsOisAssociative :: Bool
            _lhsOcopy :: BinOp
            _lhsOcomments :: ([MToken])
            _lhsOpretty =
              ( zeroWidthText (if cStyle _lhsIppconf then "&&" else "and")
              )
            _lhsOisMultiline =
              ( False
              )
            _lhsOprecedence =
              ( OperatorLevel2
              )
            _lhsOisAssociative =
              ( True
              )
            _copy =
              ( AAnd
              )
            _lhsOcopy =
              ( _copy
              )
            _lhsOcomments =
              ( _lhsIcomments
              )
          in
            (_lhsOcomments, _lhsOcopy, _lhsOisAssociative, _lhsOisMultiline, _lhsOprecedence, _lhsOpretty)
        )
  )
sem_BinOp_ALT :: T_BinOp
sem_BinOp_ALT =
  ( \_lhsIcomments
     _lhsIindent
     _lhsIppconf ->
        ( let
            _lhsOpretty :: Doc
            _lhsOisMultiline :: Bool
            _lhsOprecedence :: OperatorLevel
            _lhsOisAssociative :: Bool
            _lhsOcopy :: BinOp
            _lhsOcomments :: ([MToken])
            _lhsOpretty =
              ( zeroWidthText "<"
              )
            _lhsOisMultiline =
              ( False
              )
            _lhsOprecedence =
              ( OperatorLevel3
              )
            _lhsOisAssociative =
              ( True
              )
            _copy =
              ( ALT
              )
            _lhsOcopy =
              ( _copy
              )
            _lhsOcomments =
              ( _lhsIcomments
              )
          in
            (_lhsOcomments, _lhsOcopy, _lhsOisAssociative, _lhsOisMultiline, _lhsOprecedence, _lhsOpretty)
        )
  )
sem_BinOp_AGT :: T_BinOp
sem_BinOp_AGT =
  ( \_lhsIcomments
     _lhsIindent
     _lhsIppconf ->
        ( let
            _lhsOpretty :: Doc
            _lhsOisMultiline :: Bool
            _lhsOprecedence :: OperatorLevel
            _lhsOisAssociative :: Bool
            _lhsOcopy :: BinOp
            _lhsOcomments :: ([MToken])
            _lhsOpretty =
              ( zeroWidthText ">"
              )
            _lhsOisMultiline =
              ( False
              )
            _lhsOprecedence =
              ( OperatorLevel3
              )
            _lhsOisAssociative =
              ( True
              )
            _copy =
              ( AGT
              )
            _lhsOcopy =
              ( _copy
              )
            _lhsOcomments =
              ( _lhsIcomments
              )
          in
            (_lhsOcomments, _lhsOcopy, _lhsOisAssociative, _lhsOisMultiline, _lhsOprecedence, _lhsOpretty)
        )
  )
sem_BinOp_ALEQ :: T_BinOp
sem_BinOp_ALEQ =
  ( \_lhsIcomments
     _lhsIindent
     _lhsIppconf ->
        ( let
            _lhsOpretty :: Doc
            _lhsOisMultiline :: Bool
            _lhsOprecedence :: OperatorLevel
            _lhsOisAssociative :: Bool
            _lhsOcopy :: BinOp
            _lhsOcomments :: ([MToken])
            _lhsOpretty =
              ( zeroWidthText "<="
              )
            _lhsOisMultiline =
              ( False
              )
            _lhsOprecedence =
              ( OperatorLevel3
              )
            _lhsOisAssociative =
              ( True
              )
            _copy =
              ( ALEQ
              )
            _lhsOcopy =
              ( _copy
              )
            _lhsOcomments =
              ( _lhsIcomments
              )
          in
            (_lhsOcomments, _lhsOcopy, _lhsOisAssociative, _lhsOisMultiline, _lhsOprecedence, _lhsOpretty)
        )
  )
sem_BinOp_AGEQ :: T_BinOp
sem_BinOp_AGEQ =
  ( \_lhsIcomments
     _lhsIindent
     _lhsIppconf ->
        ( let
            _lhsOpretty :: Doc
            _lhsOisMultiline :: Bool
            _lhsOprecedence :: OperatorLevel
            _lhsOisAssociative :: Bool
            _lhsOcopy :: BinOp
            _lhsOcomments :: ([MToken])
            _lhsOpretty =
              ( zeroWidthText ">="
              )
            _lhsOisMultiline =
              ( False
              )
            _lhsOprecedence =
              ( OperatorLevel3
              )
            _lhsOisAssociative =
              ( True
              )
            _copy =
              ( AGEQ
              )
            _lhsOcopy =
              ( _copy
              )
            _lhsOcomments =
              ( _lhsIcomments
              )
          in
            (_lhsOcomments, _lhsOcopy, _lhsOisAssociative, _lhsOisMultiline, _lhsOprecedence, _lhsOpretty)
        )
  )
sem_BinOp_ANEq :: T_BinOp
sem_BinOp_ANEq =
  ( \_lhsIcomments
     _lhsIindent
     _lhsIppconf ->
        ( let
            _lhsOpretty :: Doc
            _lhsOisMultiline :: Bool
            _lhsOprecedence :: OperatorLevel
            _lhsOisAssociative :: Bool
            _lhsOcopy :: BinOp
            _lhsOcomments :: ([MToken])
            _lhsOpretty =
              ( zeroWidthText (if cStyle _lhsIppconf then "!=" else "~=")
              )
            _lhsOisMultiline =
              ( False
              )
            _lhsOprecedence =
              ( OperatorLevel3
              )
            _lhsOisAssociative =
              ( True
              )
            _copy =
              ( ANEq
              )
            _lhsOcopy =
              ( _copy
              )
            _lhsOcomments =
              ( _lhsIcomments
              )
          in
            (_lhsOcomments, _lhsOcopy, _lhsOisAssociative, _lhsOisMultiline, _lhsOprecedence, _lhsOpretty)
        )
  )
sem_BinOp_AEq :: T_BinOp
sem_BinOp_AEq =
  ( \_lhsIcomments
     _lhsIindent
     _lhsIppconf ->
        ( let
            _lhsOpretty :: Doc
            _lhsOisMultiline :: Bool
            _lhsOprecedence :: OperatorLevel
            _lhsOisAssociative :: Bool
            _lhsOcopy :: BinOp
            _lhsOcomments :: ([MToken])
            _lhsOpretty =
              ( zeroWidthText "=="
              )
            _lhsOisMultiline =
              ( False
              )
            _lhsOprecedence =
              ( OperatorLevel3
              )
            _lhsOisAssociative =
              ( True
              )
            _copy =
              ( AEq
              )
            _lhsOcopy =
              ( _copy
              )
            _lhsOcomments =
              ( _lhsIcomments
              )
          in
            (_lhsOcomments, _lhsOcopy, _lhsOisAssociative, _lhsOisMultiline, _lhsOprecedence, _lhsOpretty)
        )
  )
sem_BinOp_AConcatenate :: T_BinOp
sem_BinOp_AConcatenate =
  ( \_lhsIcomments
     _lhsIindent
     _lhsIppconf ->
        ( let
            _lhsOpretty :: Doc
            _lhsOisMultiline :: Bool
            _lhsOprecedence :: OperatorLevel
            _lhsOisAssociative :: Bool
            _lhsOcopy :: BinOp
            _lhsOcomments :: ([MToken])
            _lhsOpretty =
              ( zeroWidthText ".."
              )
            _lhsOisMultiline =
              ( False
              )
            _lhsOprecedence =
              ( OperatorLevel4
              )
            _lhsOisAssociative =
              ( True
              )
            _copy =
              ( AConcatenate
              )
            _lhsOcopy =
              ( _copy
              )
            _lhsOcomments =
              ( _lhsIcomments
              )
          in
            (_lhsOcomments, _lhsOcopy, _lhsOisAssociative, _lhsOisMultiline, _lhsOprecedence, _lhsOpretty)
        )
  )
sem_BinOp_APlus :: T_BinOp
sem_BinOp_APlus =
  ( \_lhsIcomments
     _lhsIindent
     _lhsIppconf ->
        ( let
            _lhsOpretty :: Doc
            _lhsOisMultiline :: Bool
            _lhsOprecedence :: OperatorLevel
            _lhsOisAssociative :: Bool
            _lhsOcopy :: BinOp
            _lhsOcomments :: ([MToken])
            _lhsOpretty =
              ( zeroWidthText "+"
              )
            _lhsOisMultiline =
              ( False
              )
            _lhsOprecedence =
              ( OperatorLevel5
              )
            _lhsOisAssociative =
              ( True
              )
            _copy =
              ( APlus
              )
            _lhsOcopy =
              ( _copy
              )
            _lhsOcomments =
              ( _lhsIcomments
              )
          in
            (_lhsOcomments, _lhsOcopy, _lhsOisAssociative, _lhsOisMultiline, _lhsOprecedence, _lhsOpretty)
        )
  )
sem_BinOp_BinMinus :: T_BinOp
sem_BinOp_BinMinus =
  ( \_lhsIcomments
     _lhsIindent
     _lhsIppconf ->
        ( let
            _lhsOpretty :: Doc
            _lhsOisMultiline :: Bool
            _lhsOprecedence :: OperatorLevel
            _lhsOisAssociative :: Bool
            _lhsOcopy :: BinOp
            _lhsOcomments :: ([MToken])
            _lhsOpretty =
              ( zeroWidthText "-"
              )
            _lhsOisMultiline =
              ( False
              )
            _lhsOprecedence =
              ( OperatorLevel5
              )
            _lhsOisAssociative =
              ( False
              )
            _copy =
              ( BinMinus
              )
            _lhsOcopy =
              ( _copy
              )
            _lhsOcomments =
              ( _lhsIcomments
              )
          in
            (_lhsOcomments, _lhsOcopy, _lhsOisAssociative, _lhsOisMultiline, _lhsOprecedence, _lhsOpretty)
        )
  )
sem_BinOp_AMultiply :: T_BinOp
sem_BinOp_AMultiply =
  ( \_lhsIcomments
     _lhsIindent
     _lhsIppconf ->
        ( let
            _lhsOpretty :: Doc
            _lhsOisMultiline :: Bool
            _lhsOprecedence :: OperatorLevel
            _lhsOisAssociative :: Bool
            _lhsOcopy :: BinOp
            _lhsOcomments :: ([MToken])
            _lhsOpretty =
              ( zeroWidthText "*"
              )
            _lhsOisMultiline =
              ( False
              )
            _lhsOprecedence =
              ( OperatorLevel6
              )
            _lhsOisAssociative =
              ( True
              )
            _copy =
              ( AMultiply
              )
            _lhsOcopy =
              ( _copy
              )
            _lhsOcomments =
              ( _lhsIcomments
              )
          in
            (_lhsOcomments, _lhsOcopy, _lhsOisAssociative, _lhsOisMultiline, _lhsOprecedence, _lhsOpretty)
        )
  )
sem_BinOp_ADivide :: T_BinOp
sem_BinOp_ADivide =
  ( \_lhsIcomments
     _lhsIindent
     _lhsIppconf ->
        ( let
            _lhsOpretty :: Doc
            _lhsOisMultiline :: Bool
            _lhsOprecedence :: OperatorLevel
            _lhsOisAssociative :: Bool
            _lhsOcopy :: BinOp
            _lhsOcomments :: ([MToken])
            _lhsOpretty =
              ( zeroWidthText "/"
              )
            _lhsOisMultiline =
              ( False
              )
            _lhsOprecedence =
              ( OperatorLevel6
              )
            _lhsOisAssociative =
              ( False
              )
            _copy =
              ( ADivide
              )
            _lhsOcopy =
              ( _copy
              )
            _lhsOcomments =
              ( _lhsIcomments
              )
          in
            (_lhsOcomments, _lhsOcopy, _lhsOisAssociative, _lhsOisMultiline, _lhsOprecedence, _lhsOpretty)
        )
  )
sem_BinOp_AModulus :: T_BinOp
sem_BinOp_AModulus =
  ( \_lhsIcomments
     _lhsIindent
     _lhsIppconf ->
        ( let
            _lhsOpretty :: Doc
            _lhsOisMultiline :: Bool
            _lhsOprecedence :: OperatorLevel
            _lhsOisAssociative :: Bool
            _lhsOcopy :: BinOp
            _lhsOcomments :: ([MToken])
            _lhsOpretty =
              ( zeroWidthText "%"
              )
            _lhsOisMultiline =
              ( False
              )
            _lhsOprecedence =
              ( OperatorLevel6
              )
            _lhsOisAssociative =
              ( False
              )
            _copy =
              ( AModulus
              )
            _lhsOcopy =
              ( _copy
              )
            _lhsOcomments =
              ( _lhsIcomments
              )
          in
            (_lhsOcomments, _lhsOcopy, _lhsOisAssociative, _lhsOisMultiline, _lhsOprecedence, _lhsOpretty)
        )
  )
sem_BinOp_APower :: T_BinOp
sem_BinOp_APower =
  ( \_lhsIcomments
     _lhsIindent
     _lhsIppconf ->
        ( let
            _lhsOpretty :: Doc
            _lhsOisMultiline :: Bool
            _lhsOprecedence :: OperatorLevel
            _lhsOisAssociative :: Bool
            _lhsOcopy :: BinOp
            _lhsOcomments :: ([MToken])
            _lhsOpretty =
              ( zeroWidthText "^"
              )
            _lhsOisMultiline =
              ( False
              )
            _lhsOprecedence =
              ( OperatorLevel8
              )
            _lhsOisAssociative =
              ( False
              )
            _copy =
              ( APower
              )
            _lhsOcopy =
              ( _copy
              )
            _lhsOcomments =
              ( _lhsIcomments
              )
          in
            (_lhsOcomments, _lhsOcopy, _lhsOisAssociative, _lhsOisMultiline, _lhsOprecedence, _lhsOpretty)
        )
  )

-- Block -------------------------------------------------------
-- cata
sem_Block
  :: Block
  -> T_Block
sem_Block (Block _stats _ret) =
  (sem_Block_Block (sem_MStatList _stats) (sem_AReturn _ret))

-- semantic domain
type T_Block =
  ([MToken])
  -> Bool
  -> Int
  -> PrettyPrintConfig
  -> Region
  -> (([MToken]), Block, Bool, Doc, Int)
data Inh_Block = Inh_Block {comments_Inh_Block :: ([MToken]), forceMultiline_Inh_Block :: Bool, indent_Inh_Block :: Int, ppconf_Inh_Block :: PrettyPrintConfig, statRegion_Inh_Block :: Region}
data Syn_Block = Syn_Block {comments_Syn_Block :: ([MToken]), copy_Syn_Block :: Block, isMultiline_Syn_Block :: Bool, pretty_Syn_Block :: Doc, statementCount_Syn_Block :: Int}
wrap_Block
  :: T_Block
  -> Inh_Block
  -> Syn_Block
wrap_Block sem (Inh_Block _lhsIcomments _lhsIforceMultiline _lhsIindent _lhsIppconf _lhsIstatRegion) =
  ( let
      (_lhsOcomments, _lhsOcopy, _lhsOisMultiline, _lhsOpretty, _lhsOstatementCount) = sem _lhsIcomments _lhsIforceMultiline _lhsIindent _lhsIppconf _lhsIstatRegion
    in
      (Syn_Block _lhsOcomments _lhsOcopy _lhsOisMultiline _lhsOpretty _lhsOstatementCount)
  )
sem_Block_Block
  :: T_MStatList
  -> T_AReturn
  -> T_Block
sem_Block_Block stats_ ret_ =
  ( \_lhsIcomments
     _lhsIforceMultiline
     _lhsIindent
     _lhsIppconf
     _lhsIstatRegion ->
        ( let
            _lhsOpretty :: Doc
            _lhsOstatementCount :: Int
            _lhsOcopy :: Block
            _lhsOcomments :: ([MToken])
            _lhsOisMultiline :: Bool
            _statsOcomments :: ([MToken])
            _statsOforceMultiline :: Bool
            _statsOindent :: Int
            _statsOppconf :: PrettyPrintConfig
            _statsOstatRegion :: Region
            _retOcomments :: ([MToken])
            _retOforceMultiline :: Bool
            _retOindent :: Int
            _retOppconf :: PrettyPrintConfig
            _statsIcomments :: ([MToken])
            _statsIcopy :: MStatList
            _statsIisLast :: Bool
            _statsIisMultiline :: Bool
            _statsIpretty :: Doc
            _statsIstartsWithExprPrefixExpression :: Bool
            _statsIstatementCount :: Int
            _retIcomments :: ([MToken])
            _retIcopy :: AReturn
            _retIisMultiline :: Bool
            _retIpretty :: Doc
            _retIstatementCount :: Int
            _lhsOpretty =
              ( if _isMultiline
                  then _statsIpretty $+$ _retIpretty
                  else _statsIpretty <-> _retIpretty
              )
            _statementCount =
              ( _statsIstatementCount + _retIstatementCount
              )
            _isMultiline =
              ( _statsIisMultiline || _retIisMultiline || _statementCount > 1
              )
            _lhsOstatementCount =
              ( _statementCount
              )
            _copy =
              ( Block _statsIcopy _retIcopy
              )
            _lhsOcopy =
              ( _copy
              )
            _lhsOcomments =
              ( _retIcomments
              )
            _lhsOisMultiline =
              ( _isMultiline
              )
            _statsOcomments =
              ( _lhsIcomments
              )
            _statsOforceMultiline =
              ( _lhsIforceMultiline
              )
            _statsOindent =
              ( _lhsIindent
              )
            _statsOppconf =
              ( _lhsIppconf
              )
            _statsOstatRegion =
              ( _lhsIstatRegion
              )
            _retOcomments =
              ( _statsIcomments
              )
            _retOforceMultiline =
              ( _lhsIforceMultiline
              )
            _retOindent =
              ( _lhsIindent
              )
            _retOppconf =
              ( _lhsIppconf
              )
            (_statsIcomments, _statsIcopy, _statsIisLast, _statsIisMultiline, _statsIpretty, _statsIstartsWithExprPrefixExpression, _statsIstatementCount) =
              stats_ _statsOcomments _statsOforceMultiline _statsOindent _statsOppconf _statsOstatRegion
            (_retIcomments, _retIcopy, _retIisMultiline, _retIpretty, _retIstatementCount) =
              ret_ _retOcomments _retOforceMultiline _retOindent _retOppconf
          in
            (_lhsOcomments, _lhsOcopy, _lhsOisMultiline, _lhsOpretty, _lhsOstatementCount)
        )
  )

-- Declaration -------------------------------------------------
-- cata
sem_Declaration
  :: Declaration
  -> T_Declaration
sem_Declaration (x1, x2) =
  (sem_Declaration_Tuple (sem_PrefixExp x1) (sem_MaybeMExpr x2))

-- semantic domain
type T_Declaration =
  ([MToken])
  -> Bool
  -> Int
  -> PrettyPrintConfig
  -> (([MToken]), Declaration, Bool, Doc, Bool, Bool, Doc, Bool, Doc)
data Inh_Declaration = Inh_Declaration {comments_Inh_Declaration :: ([MToken]), forceMultiline_Inh_Declaration :: Bool, indent_Inh_Declaration :: Int, ppconf_Inh_Declaration :: PrettyPrintConfig}
data Syn_Declaration = Syn_Declaration {comments_Syn_Declaration :: ([MToken]), copy_Syn_Declaration :: Declaration, endsWithPrefixExpression_Syn_Declaration :: Bool, exprPretty_Syn_Declaration :: Doc, isDefined_Syn_Declaration :: Bool, isMultiline_Syn_Declaration :: Bool, pretty_Syn_Declaration :: Doc, startsWithExprPrefixExpression_Syn_Declaration :: Bool, varPretty_Syn_Declaration :: Doc}
wrap_Declaration
  :: T_Declaration
  -> Inh_Declaration
  -> Syn_Declaration
wrap_Declaration sem (Inh_Declaration _lhsIcomments _lhsIforceMultiline _lhsIindent _lhsIppconf) =
  ( let
      (_lhsOcomments, _lhsOcopy, _lhsOendsWithPrefixExpression, _lhsOexprPretty, _lhsOisDefined, _lhsOisMultiline, _lhsOpretty, _lhsOstartsWithExprPrefixExpression, _lhsOvarPretty) = sem _lhsIcomments _lhsIforceMultiline _lhsIindent _lhsIppconf
    in
      (Syn_Declaration _lhsOcomments _lhsOcopy _lhsOendsWithPrefixExpression _lhsOexprPretty _lhsOisDefined _lhsOisMultiline _lhsOpretty _lhsOstartsWithExprPrefixExpression _lhsOvarPretty)
  )
sem_Declaration_Tuple
  :: T_PrefixExp
  -> T_MaybeMExpr
  -> T_Declaration
sem_Declaration_Tuple x1_ x2_ =
  ( \_lhsIcomments
     _lhsIforceMultiline
     _lhsIindent
     _lhsIppconf ->
        ( let
            _lhsOvarPretty :: Doc
            _lhsOexprPretty :: Doc
            _lhsOstartsWithExprPrefixExpression :: Bool
            _lhsOendsWithPrefixExpression :: Bool
            _lhsOisMultiline :: Bool
            _x1OparentOperatorPrecedence :: OperatorLevel
            _x1OparentOperatorAssociative :: Bool
            _lhsOisDefined :: Bool
            _lhsOcopy :: Declaration
            _lhsOcomments :: ([MToken])
            _lhsOpretty :: Doc
            _x1Ocomments :: ([MToken])
            _x1OforceMultiline :: Bool
            _x1Oindent :: Int
            _x1Oppconf :: PrettyPrintConfig
            _x2Ocomments :: ([MToken])
            _x2OforceMultiline :: Bool
            _x2Oindent :: Int
            _x2Oppconf :: PrettyPrintConfig
            _x1Icomments :: ([MToken])
            _x1Icopy :: PrefixExp
            _x1IisAssociative :: Bool
            _x1IisLiteral :: Bool
            _x1IisMultiline :: Bool
            _x1Iprecedence :: OperatorLevel
            _x1Ipretty :: Doc
            _x1IstartsWithExprPrefixExpression :: Bool
            _x2Icomments :: ([MToken])
            _x2Icopy :: MaybeMExpr
            _x2IendsWithPrefixExpression :: Bool
            _x2IisAssociative :: Bool
            _x2IisDefined :: Bool
            _x2IisMultiline :: Bool
            _x2Iprecedence :: OperatorLevel
            _x2Ipretty :: Doc
            _lhsOvarPretty =
              ( _x1Ipretty
              )
            _lhsOexprPretty =
              ( _x2Ipretty
              )
            _lhsOstartsWithExprPrefixExpression =
              ( _x1IstartsWithExprPrefixExpression
              )
            _lhsOendsWithPrefixExpression =
              ( _x2IendsWithPrefixExpression
              )
            _lhsOisMultiline =
              ( _x1IisMultiline || _x2IisMultiline
              )
            _x1OparentOperatorPrecedence =
              ( TopLevelExpression
              )
            _x1OparentOperatorAssociative =
              ( True
              )
            _lhsOisDefined =
              ( _x2IisDefined
              )
            _copy =
              ( (_x1Icopy, _x2Icopy)
              )
            _lhsOcopy =
              ( _copy
              )
            _lhsOcomments =
              ( _x2Icomments
              )
            _lhsOpretty =
              ( _x2Ipretty
              )
            _x1Ocomments =
              ( _lhsIcomments
              )
            _x1OforceMultiline =
              ( _lhsIforceMultiline
              )
            _x1Oindent =
              ( _lhsIindent
              )
            _x1Oppconf =
              ( _lhsIppconf
              )
            _x2Ocomments =
              ( _x1Icomments
              )
            _x2OforceMultiline =
              ( _lhsIforceMultiline
              )
            _x2Oindent =
              ( _lhsIindent
              )
            _x2Oppconf =
              ( _lhsIppconf
              )
            (_x1Icomments, _x1Icopy, _x1IisAssociative, _x1IisLiteral, _x1IisMultiline, _x1Iprecedence, _x1Ipretty, _x1IstartsWithExprPrefixExpression) =
              x1_ _x1Ocomments _x1OforceMultiline _x1Oindent _x1OparentOperatorAssociative _x1OparentOperatorPrecedence _x1Oppconf
            (_x2Icomments, _x2Icopy, _x2IendsWithPrefixExpression, _x2IisAssociative, _x2IisDefined, _x2IisMultiline, _x2Iprecedence, _x2Ipretty) =
              x2_ _x2Ocomments _x2OforceMultiline _x2Oindent _x2Oppconf
          in
            (_lhsOcomments, _lhsOcopy, _lhsOendsWithPrefixExpression, _lhsOexprPretty, _lhsOisDefined, _lhsOisMultiline, _lhsOpretty, _lhsOstartsWithExprPrefixExpression, _lhsOvarPretty)
        )
  )

-- Else --------------------------------------------------------
-- cata
sem_Else
  :: Else
  -> T_Else
sem_Else (Prelude.Just x) =
  (sem_Else_Just (sem_MElse x))
sem_Else Prelude.Nothing =
  sem_Else_Nothing

-- semantic domain
type T_Else =
  ([MToken])
  -> Bool
  -> Int
  -> PrettyPrintConfig
  -> Region
  -> (([MToken]), Else, Bool, Bool, Region, Doc)
data Inh_Else = Inh_Else {comments_Inh_Else :: ([MToken]), forceMultiline_Inh_Else :: Bool, indent_Inh_Else :: Int, ppconf_Inh_Else :: PrettyPrintConfig, statRegion_Inh_Else :: Region}
data Syn_Else = Syn_Else {comments_Syn_Else :: ([MToken]), copy_Syn_Else :: Else, elsesExist_Syn_Else :: Bool, isMultiline_Syn_Else :: Bool, pos_Syn_Else :: Region, pretty_Syn_Else :: Doc}
wrap_Else
  :: T_Else
  -> Inh_Else
  -> Syn_Else
wrap_Else sem (Inh_Else _lhsIcomments _lhsIforceMultiline _lhsIindent _lhsIppconf _lhsIstatRegion) =
  ( let
      (_lhsOcomments, _lhsOcopy, _lhsOelsesExist, _lhsOisMultiline, _lhsOpos, _lhsOpretty) = sem _lhsIcomments _lhsIforceMultiline _lhsIindent _lhsIppconf _lhsIstatRegion
    in
      (Syn_Else _lhsOcomments _lhsOcopy _lhsOelsesExist _lhsOisMultiline _lhsOpos _lhsOpretty)
  )
sem_Else_Just
  :: T_MElse
  -> T_Else
sem_Else_Just just_ =
  ( \_lhsIcomments
     _lhsIforceMultiline
     _lhsIindent
     _lhsIppconf
     _lhsIstatRegion ->
        ( let
            _lhsOelsesExist :: Bool
            _lhsOisMultiline :: Bool
            _lhsOcopy :: Else
            _lhsOcomments :: ([MToken])
            _lhsOpos :: Region
            _lhsOpretty :: Doc
            _justOcomments :: ([MToken])
            _justOforceMultiline :: Bool
            _justOindent :: Int
            _justOppconf :: PrettyPrintConfig
            _justOstatRegion :: Region
            _justIcomments :: ([MToken])
            _justIcopy :: MElse
            _justIelsesExist :: Bool
            _justIisMultiline :: Bool
            _justIpos :: Region
            _justIpretty :: Doc
            _lhsOelsesExist =
              ( True
              )
            _lhsOisMultiline =
              ( _justIisMultiline
              )
            _copy =
              ( Just _justIcopy
              )
            _lhsOcopy =
              ( _copy
              )
            _lhsOcomments =
              ( _justIcomments
              )
            _lhsOpos =
              ( _justIpos
              )
            _lhsOpretty =
              ( _justIpretty
              )
            _justOcomments =
              ( _lhsIcomments
              )
            _justOforceMultiline =
              ( _lhsIforceMultiline
              )
            _justOindent =
              ( _lhsIindent
              )
            _justOppconf =
              ( _lhsIppconf
              )
            _justOstatRegion =
              ( _lhsIstatRegion
              )
            (_justIcomments, _justIcopy, _justIelsesExist, _justIisMultiline, _justIpos, _justIpretty) =
              just_ _justOcomments _justOforceMultiline _justOindent _justOppconf _justOstatRegion
          in
            (_lhsOcomments, _lhsOcopy, _lhsOelsesExist, _lhsOisMultiline, _lhsOpos, _lhsOpretty)
        )
  )
sem_Else_Nothing :: T_Else
sem_Else_Nothing =
  ( \_lhsIcomments
     _lhsIforceMultiline
     _lhsIindent
     _lhsIppconf
     _lhsIstatRegion ->
        ( let
            _lhsOpretty :: Doc
            _lhsOpos :: Region
            _lhsOisMultiline :: Bool
            _lhsOelsesExist :: Bool
            _lhsOcopy :: Else
            _lhsOcomments :: ([MToken])
            _lhsOpretty =
              ( empty
              )
            _lhsOpos =
              ( emptyRg
              )
            _lhsOisMultiline =
              ( False
              )
            _lhsOelsesExist =
              ( False
              )
            _copy =
              ( Nothing
              )
            _lhsOcopy =
              ( _copy
              )
            _lhsOcomments =
              ( _lhsIcomments
              )
          in
            (_lhsOcomments, _lhsOcopy, _lhsOelsesExist, _lhsOisMultiline, _lhsOpos, _lhsOpretty)
        )
  )

-- ElseIf ------------------------------------------------------
-- cata
sem_ElseIf
  :: ElseIf
  -> T_ElseIf
sem_ElseIf (x1, x2) =
  (sem_ElseIf_Tuple (sem_MExpr x1) (sem_Block x2))

-- semantic domain
type T_ElseIf =
  ([MToken])
  -> Bool
  -> Int
  -> PrettyPrintConfig
  -> (([MToken]), ElseIf, Bool, Doc)
data Inh_ElseIf = Inh_ElseIf {comments_Inh_ElseIf :: ([MToken]), forceMultiline_Inh_ElseIf :: Bool, indent_Inh_ElseIf :: Int, ppconf_Inh_ElseIf :: PrettyPrintConfig}
data Syn_ElseIf = Syn_ElseIf {comments_Syn_ElseIf :: ([MToken]), copy_Syn_ElseIf :: ElseIf, isMultiline_Syn_ElseIf :: Bool, pretty_Syn_ElseIf :: Doc}
wrap_ElseIf
  :: T_ElseIf
  -> Inh_ElseIf
  -> Syn_ElseIf
wrap_ElseIf sem (Inh_ElseIf _lhsIcomments _lhsIforceMultiline _lhsIindent _lhsIppconf) =
  ( let
      (_lhsOcomments, _lhsOcopy, _lhsOisMultiline, _lhsOpretty) = sem _lhsIcomments _lhsIforceMultiline _lhsIindent _lhsIppconf
    in
      (Syn_ElseIf _lhsOcomments _lhsOcopy _lhsOisMultiline _lhsOpretty)
  )
sem_ElseIf_Tuple
  :: T_MExpr
  -> T_Block
  -> T_ElseIf
sem_ElseIf_Tuple x1_ x2_ =
  ( \_lhsIcomments
     _lhsIforceMultiline
     _lhsIindent
     _lhsIppconf ->
        ( let
            _lhsOpretty :: Doc
            _lhsOisMultiline :: Bool
            _x2Oindent :: Int
            _x2OstatRegion :: Region
            _x1OparentOperatorPrecedence :: OperatorLevel
            _x1OparentOperatorAssociative :: Bool
            _lhsOcopy :: ElseIf
            _lhsOcomments :: ([MToken])
            _x1Ocomments :: ([MToken])
            _x1OforceMultiline :: Bool
            _x1Oindent :: Int
            _x1Oppconf :: PrettyPrintConfig
            _x2Ocomments :: ([MToken])
            _x2OforceMultiline :: Bool
            _x2Oppconf :: PrettyPrintConfig
            _x1Icomments :: ([MToken])
            _x1Icopy :: MExpr
            _x1IendsWithPrefixExpression :: Bool
            _x1IisAssociative :: Bool
            _x1IisLiteral :: Bool
            _x1IisMultiline :: Bool
            _x1Ipos :: Region
            _x1Iprecedence :: OperatorLevel
            _x1Ipretty :: Doc
            _x2Icomments :: ([MToken])
            _x2Icopy :: Block
            _x2IisMultiline :: Bool
            _x2Ipretty :: Doc
            _x2IstatementCount :: Int
            _lhsOpretty =
              ( zeroWidthText "elseif" <-> _x1Ipretty <-> zeroWidthText "then" $+$ _x2Ipretty
              )
            _lhsOisMultiline =
              ( _x1IisMultiline || _x2IisMultiline
              )
            _x2Oindent =
              ( _lhsIindent + 1
              )
            _x2OstatRegion =
              ( emptyRg
              )
            _x1OparentOperatorPrecedence =
              ( TopLevelExpression
              )
            _x1OparentOperatorAssociative =
              ( True
              )
            _copy =
              ( (_x1Icopy, _x2Icopy)
              )
            _lhsOcopy =
              ( _copy
              )
            _lhsOcomments =
              ( _x2Icomments
              )
            _x1Ocomments =
              ( _lhsIcomments
              )
            _x1OforceMultiline =
              ( _lhsIforceMultiline
              )
            _x1Oindent =
              ( _lhsIindent
              )
            _x1Oppconf =
              ( _lhsIppconf
              )
            _x2Ocomments =
              ( _x1Icomments
              )
            _x2OforceMultiline =
              ( _lhsIforceMultiline
              )
            _x2Oppconf =
              ( _lhsIppconf
              )
            (_x1Icomments, _x1Icopy, _x1IendsWithPrefixExpression, _x1IisAssociative, _x1IisLiteral, _x1IisMultiline, _x1Ipos, _x1Iprecedence, _x1Ipretty) =
              x1_ _x1Ocomments _x1OforceMultiline _x1Oindent _x1OparentOperatorAssociative _x1OparentOperatorPrecedence _x1Oppconf
            (_x2Icomments, _x2Icopy, _x2IisMultiline, _x2Ipretty, _x2IstatementCount) =
              x2_ _x2Ocomments _x2OforceMultiline _x2Oindent _x2Oppconf _x2OstatRegion
          in
            (_lhsOcomments, _lhsOcopy, _lhsOisMultiline, _lhsOpretty)
        )
  )

-- ElseIfList --------------------------------------------------
-- cata
sem_ElseIfList
  :: ElseIfList
  -> T_ElseIfList
sem_ElseIfList list =
  (Prelude.foldr sem_ElseIfList_Cons sem_ElseIfList_Nil (Prelude.map sem_MElseIf list))

-- semantic domain
type T_ElseIfList =
  ([MToken])
  -> Bool
  -> Int
  -> PrettyPrintConfig
  -> (([MToken]), ElseIfList, Bool, Bool, Region, Doc)
data Inh_ElseIfList = Inh_ElseIfList {comments_Inh_ElseIfList :: ([MToken]), forceMultiline_Inh_ElseIfList :: Bool, indent_Inh_ElseIfList :: Int, ppconf_Inh_ElseIfList :: PrettyPrintConfig}
data Syn_ElseIfList = Syn_ElseIfList {comments_Syn_ElseIfList :: ([MToken]), copy_Syn_ElseIfList :: ElseIfList, elsesExist_Syn_ElseIfList :: Bool, isMultiline_Syn_ElseIfList :: Bool, pos_Syn_ElseIfList :: Region, pretty_Syn_ElseIfList :: Doc}
wrap_ElseIfList
  :: T_ElseIfList
  -> Inh_ElseIfList
  -> Syn_ElseIfList
wrap_ElseIfList sem (Inh_ElseIfList _lhsIcomments _lhsIforceMultiline _lhsIindent _lhsIppconf) =
  ( let
      (_lhsOcomments, _lhsOcopy, _lhsOelsesExist, _lhsOisMultiline, _lhsOpos, _lhsOpretty) = sem _lhsIcomments _lhsIforceMultiline _lhsIindent _lhsIppconf
    in
      (Syn_ElseIfList _lhsOcomments _lhsOcopy _lhsOelsesExist _lhsOisMultiline _lhsOpos _lhsOpretty)
  )
sem_ElseIfList_Cons
  :: T_MElseIf
  -> T_ElseIfList
  -> T_ElseIfList
sem_ElseIfList_Cons hd_ tl_ =
  ( \_lhsIcomments
     _lhsIforceMultiline
     _lhsIindent
     _lhsIppconf ->
        ( let
            _lhsOpretty :: Doc
            _lhsOelsesExist :: Bool
            _lhsOpos :: Region
            _lhsOisMultiline :: Bool
            _lhsOcopy :: ElseIfList
            _lhsOcomments :: ([MToken])
            _hdOcomments :: ([MToken])
            _hdOforceMultiline :: Bool
            _hdOindent :: Int
            _hdOppconf :: PrettyPrintConfig
            _tlOcomments :: ([MToken])
            _tlOforceMultiline :: Bool
            _tlOindent :: Int
            _tlOppconf :: PrettyPrintConfig
            _hdIcomments :: ([MToken])
            _hdIcopy :: MElseIf
            _hdIisMultiline :: Bool
            _hdIpos :: Region
            _hdIpretty :: Doc
            _tlIcomments :: ([MToken])
            _tlIcopy :: ElseIfList
            _tlIelsesExist :: Bool
            _tlIisMultiline :: Bool
            _tlIpos :: Region
            _tlIpretty :: Doc
            _lhsOpretty =
              ( indent _lhsIppconf _lhsIindent _hdIpretty $+$ _tlIpretty
              )
            _lhsOelsesExist =
              ( True
              )
            _lhsOpos =
              ( _hdIpos
              )
            _lhsOisMultiline =
              ( _hdIisMultiline || _tlIisMultiline
              )
            _copy =
              ( (:) _hdIcopy _tlIcopy
              )
            _lhsOcopy =
              ( _copy
              )
            _lhsOcomments =
              ( _tlIcomments
              )
            _hdOcomments =
              ( _lhsIcomments
              )
            _hdOforceMultiline =
              ( _lhsIforceMultiline
              )
            _hdOindent =
              ( _lhsIindent
              )
            _hdOppconf =
              ( _lhsIppconf
              )
            _tlOcomments =
              ( _hdIcomments
              )
            _tlOforceMultiline =
              ( _lhsIforceMultiline
              )
            _tlOindent =
              ( _lhsIindent
              )
            _tlOppconf =
              ( _lhsIppconf
              )
            (_hdIcomments, _hdIcopy, _hdIisMultiline, _hdIpos, _hdIpretty) =
              hd_ _hdOcomments _hdOforceMultiline _hdOindent _hdOppconf
            (_tlIcomments, _tlIcopy, _tlIelsesExist, _tlIisMultiline, _tlIpos, _tlIpretty) =
              tl_ _tlOcomments _tlOforceMultiline _tlOindent _tlOppconf
          in
            (_lhsOcomments, _lhsOcopy, _lhsOelsesExist, _lhsOisMultiline, _lhsOpos, _lhsOpretty)
        )
  )
sem_ElseIfList_Nil :: T_ElseIfList
sem_ElseIfList_Nil =
  ( \_lhsIcomments
     _lhsIforceMultiline
     _lhsIindent
     _lhsIppconf ->
        ( let
            _lhsOpretty :: Doc
            _lhsOpos :: Region
            _lhsOisMultiline :: Bool
            _lhsOelsesExist :: Bool
            _lhsOcopy :: ElseIfList
            _lhsOcomments :: ([MToken])
            _lhsOpretty =
              ( empty
              )
            _lhsOpos =
              ( emptyRg
              )
            _lhsOisMultiline =
              ( False
              )
            _lhsOelsesExist =
              ( False
              )
            _copy =
              ( []
              )
            _lhsOcopy =
              ( _copy
              )
            _lhsOcomments =
              ( _lhsIcomments
              )
          in
            (_lhsOcomments, _lhsOcopy, _lhsOelsesExist, _lhsOisMultiline, _lhsOpos, _lhsOpretty)
        )
  )

-- Expr --------------------------------------------------------
-- cata
sem_Expr
  :: Expr
  -> T_Expr
sem_Expr (ANil) =
  (sem_Expr_ANil)
sem_Expr (AFalse) =
  (sem_Expr_AFalse)
sem_Expr (ATrue) =
  (sem_Expr_ATrue)
sem_Expr (ANumber _num) =
  (sem_Expr_ANumber _num)
sem_Expr (AString _str) =
  (sem_Expr_AString _str)
sem_Expr (AVarArg) =
  (sem_Expr_AVarArg)
sem_Expr (AnonymousFunc _pars _body) =
  (sem_Expr_AnonymousFunc _pars (sem_Block _body))
sem_Expr (APrefixExpr _pexpr) =
  (sem_Expr_APrefixExpr (sem_PrefixExp _pexpr))
sem_Expr (ATableConstructor _fields) =
  (sem_Expr_ATableConstructor (sem_FieldList _fields))
sem_Expr (BinOpExpr _op _left _right) =
  (sem_Expr_BinOpExpr (sem_BinOp _op) (sem_MExpr _left) (sem_MExpr _right))
sem_Expr (UnOpExpr _op _right) =
  (sem_Expr_UnOpExpr (sem_UnOp _op) (sem_MExpr _right))

-- semantic domain
type T_Expr =
  ([MToken])
  -> Bool
  -> Int
  -> Bool
  -> OperatorLevel
  -> PrettyPrintConfig
  -> Region
  -> (([MToken]), Expr, Bool, Bool, Bool, Bool, OperatorLevel, Doc)
data Inh_Expr = Inh_Expr {comments_Inh_Expr :: ([MToken]), forceMultiline_Inh_Expr :: Bool, indent_Inh_Expr :: Int, parentOperatorAssociative_Inh_Expr :: Bool, parentOperatorPrecedence_Inh_Expr :: OperatorLevel, ppconf_Inh_Expr :: PrettyPrintConfig, statRegion_Inh_Expr :: Region}
data Syn_Expr = Syn_Expr {comments_Syn_Expr :: ([MToken]), copy_Syn_Expr :: Expr, endsWithPrefixExpression_Syn_Expr :: Bool, isAssociative_Syn_Expr :: Bool, isLiteral_Syn_Expr :: Bool, isMultiline_Syn_Expr :: Bool, precedence_Syn_Expr :: OperatorLevel, pretty_Syn_Expr :: Doc}
wrap_Expr
  :: T_Expr
  -> Inh_Expr
  -> Syn_Expr
wrap_Expr sem (Inh_Expr _lhsIcomments _lhsIforceMultiline _lhsIindent _lhsIparentOperatorAssociative _lhsIparentOperatorPrecedence _lhsIppconf _lhsIstatRegion) =
  ( let
      (_lhsOcomments, _lhsOcopy, _lhsOendsWithPrefixExpression, _lhsOisAssociative, _lhsOisLiteral, _lhsOisMultiline, _lhsOprecedence, _lhsOpretty) = sem _lhsIcomments _lhsIforceMultiline _lhsIindent _lhsIparentOperatorAssociative _lhsIparentOperatorPrecedence _lhsIppconf _lhsIstatRegion
    in
      (Syn_Expr _lhsOcomments _lhsOcopy _lhsOendsWithPrefixExpression _lhsOisAssociative _lhsOisLiteral _lhsOisMultiline _lhsOprecedence _lhsOpretty)
  )
sem_Expr_ANil :: T_Expr
sem_Expr_ANil =
  ( \_lhsIcomments
     _lhsIforceMultiline
     _lhsIindent
     _lhsIparentOperatorAssociative
     _lhsIparentOperatorPrecedence
     _lhsIppconf
     _lhsIstatRegion ->
        ( let
            _lhsOpretty :: Doc
            _lhsOisLiteral :: Bool
            _lhsOendsWithPrefixExpression :: Bool
            _lhsOisMultiline :: Bool
            _lhsOisAssociative :: Bool
            _lhsOprecedence :: OperatorLevel
            _lhsOcopy :: Expr
            _lhsOcomments :: ([MToken])
            _lhsOpretty =
              ( zeroWidthText "nil"
              )
            _lhsOisLiteral =
              ( True
              )
            _lhsOendsWithPrefixExpression =
              ( False
              )
            _lhsOisMultiline =
              ( False
              )
            _lhsOisAssociative =
              ( False
              )
            _lhsOprecedence =
              ( OperatorLevel8
              )
            _copy =
              ( ANil
              )
            _lhsOcopy =
              ( _copy
              )
            _lhsOcomments =
              ( _lhsIcomments
              )
          in
            (_lhsOcomments, _lhsOcopy, _lhsOendsWithPrefixExpression, _lhsOisAssociative, _lhsOisLiteral, _lhsOisMultiline, _lhsOprecedence, _lhsOpretty)
        )
  )
sem_Expr_AFalse :: T_Expr
sem_Expr_AFalse =
  ( \_lhsIcomments
     _lhsIforceMultiline
     _lhsIindent
     _lhsIparentOperatorAssociative
     _lhsIparentOperatorPrecedence
     _lhsIppconf
     _lhsIstatRegion ->
        ( let
            _lhsOpretty :: Doc
            _lhsOisLiteral :: Bool
            _lhsOendsWithPrefixExpression :: Bool
            _lhsOisMultiline :: Bool
            _lhsOisAssociative :: Bool
            _lhsOprecedence :: OperatorLevel
            _lhsOcopy :: Expr
            _lhsOcomments :: ([MToken])
            _lhsOpretty =
              ( zeroWidthText "false"
              )
            _lhsOisLiteral =
              ( True
              )
            _lhsOendsWithPrefixExpression =
              ( False
              )
            _lhsOisMultiline =
              ( False
              )
            _lhsOisAssociative =
              ( False
              )
            _lhsOprecedence =
              ( OperatorLevel8
              )
            _copy =
              ( AFalse
              )
            _lhsOcopy =
              ( _copy
              )
            _lhsOcomments =
              ( _lhsIcomments
              )
          in
            (_lhsOcomments, _lhsOcopy, _lhsOendsWithPrefixExpression, _lhsOisAssociative, _lhsOisLiteral, _lhsOisMultiline, _lhsOprecedence, _lhsOpretty)
        )
  )
sem_Expr_ATrue :: T_Expr
sem_Expr_ATrue =
  ( \_lhsIcomments
     _lhsIforceMultiline
     _lhsIindent
     _lhsIparentOperatorAssociative
     _lhsIparentOperatorPrecedence
     _lhsIppconf
     _lhsIstatRegion ->
        ( let
            _lhsOpretty :: Doc
            _lhsOisLiteral :: Bool
            _lhsOendsWithPrefixExpression :: Bool
            _lhsOisMultiline :: Bool
            _lhsOisAssociative :: Bool
            _lhsOprecedence :: OperatorLevel
            _lhsOcopy :: Expr
            _lhsOcomments :: ([MToken])
            _lhsOpretty =
              ( zeroWidthText "true"
              )
            _lhsOisLiteral =
              ( True
              )
            _lhsOendsWithPrefixExpression =
              ( False
              )
            _lhsOisMultiline =
              ( False
              )
            _lhsOisAssociative =
              ( False
              )
            _lhsOprecedence =
              ( OperatorLevel8
              )
            _copy =
              ( ATrue
              )
            _lhsOcopy =
              ( _copy
              )
            _lhsOcomments =
              ( _lhsIcomments
              )
          in
            (_lhsOcomments, _lhsOcopy, _lhsOendsWithPrefixExpression, _lhsOisAssociative, _lhsOisLiteral, _lhsOisMultiline, _lhsOprecedence, _lhsOpretty)
        )
  )
sem_Expr_ANumber
  :: String
  -> T_Expr
sem_Expr_ANumber num_ =
  ( \_lhsIcomments
     _lhsIforceMultiline
     _lhsIindent
     _lhsIparentOperatorAssociative
     _lhsIparentOperatorPrecedence
     _lhsIppconf
     _lhsIstatRegion ->
        ( let
            _lhsOpretty :: Doc
            _lhsOisLiteral :: Bool
            _lhsOendsWithPrefixExpression :: Bool
            _lhsOisMultiline :: Bool
            _lhsOisAssociative :: Bool
            _lhsOprecedence :: OperatorLevel
            _lhsOcopy :: Expr
            _lhsOcomments :: ([MToken])
            _lhsOpretty =
              ( zeroWidthText num_
              )
            _lhsOisLiteral =
              ( True
              )
            _lhsOendsWithPrefixExpression =
              ( False
              )
            _lhsOisMultiline =
              ( False
              )
            _lhsOisAssociative =
              ( False
              )
            _lhsOprecedence =
              ( OperatorLevel8
              )
            _copy =
              ( ANumber num_
              )
            _lhsOcopy =
              ( _copy
              )
            _lhsOcomments =
              ( _lhsIcomments
              )
          in
            (_lhsOcomments, _lhsOcopy, _lhsOendsWithPrefixExpression, _lhsOisAssociative, _lhsOisLiteral, _lhsOisMultiline, _lhsOprecedence, _lhsOpretty)
        )
  )
sem_Expr_AString
  :: MToken
  -> T_Expr
sem_Expr_AString str_ =
  ( \_lhsIcomments
     _lhsIforceMultiline
     _lhsIindent
     _lhsIparentOperatorAssociative
     _lhsIparentOperatorPrecedence
     _lhsIppconf
     _lhsIstatRegion ->
        ( let
            _lhsOpretty :: Doc
            _lhsOisLiteral :: Bool
            _lhsOendsWithPrefixExpression :: Bool
            _lhsOisMultiline :: Bool
            _lhsOisAssociative :: Bool
            _lhsOprecedence :: OperatorLevel
            _lhsOcopy :: Expr
            _lhsOcomments :: ([MToken])
            _lhsOpretty =
              ( tok str_
              )
            _lhsOisLiteral =
              ( True
              )
            _lhsOendsWithPrefixExpression =
              ( False
              )
            _lhsOisMultiline =
              ( False
              )
            _lhsOisAssociative =
              ( False
              )
            _lhsOprecedence =
              ( OperatorLevel8
              )
            _copy =
              ( AString str_
              )
            _lhsOcopy =
              ( _copy
              )
            _lhsOcomments =
              ( _lhsIcomments
              )
          in
            (_lhsOcomments, _lhsOcopy, _lhsOendsWithPrefixExpression, _lhsOisAssociative, _lhsOisLiteral, _lhsOisMultiline, _lhsOprecedence, _lhsOpretty)
        )
  )
sem_Expr_AVarArg :: T_Expr
sem_Expr_AVarArg =
  ( \_lhsIcomments
     _lhsIforceMultiline
     _lhsIindent
     _lhsIparentOperatorAssociative
     _lhsIparentOperatorPrecedence
     _lhsIppconf
     _lhsIstatRegion ->
        ( let
            _lhsOpretty :: Doc
            _lhsOisLiteral :: Bool
            _lhsOendsWithPrefixExpression :: Bool
            _lhsOisMultiline :: Bool
            _lhsOisAssociative :: Bool
            _lhsOprecedence :: OperatorLevel
            _lhsOcopy :: Expr
            _lhsOcomments :: ([MToken])
            _lhsOpretty =
              ( zeroWidthText "..."
              )
            _lhsOisLiteral =
              ( True
              )
            _lhsOendsWithPrefixExpression =
              ( False
              )
            _lhsOisMultiline =
              ( False
              )
            _lhsOisAssociative =
              ( False
              )
            _lhsOprecedence =
              ( OperatorLevel8
              )
            _copy =
              ( AVarArg
              )
            _lhsOcopy =
              ( _copy
              )
            _lhsOcomments =
              ( _lhsIcomments
              )
          in
            (_lhsOcomments, _lhsOcopy, _lhsOendsWithPrefixExpression, _lhsOisAssociative, _lhsOisLiteral, _lhsOisMultiline, _lhsOprecedence, _lhsOpretty)
        )
  )
sem_Expr_AnonymousFunc
  :: ([MToken])
  -> T_Block
  -> T_Expr
sem_Expr_AnonymousFunc pars_ body_ =
  ( \_lhsIcomments
     _lhsIforceMultiline
     _lhsIindent
     _lhsIparentOperatorAssociative
     _lhsIparentOperatorPrecedence
     _lhsIppconf
     _lhsIstatRegion ->
        ( let
            _lhsOendsWithPrefixExpression :: Bool
            _bodyOindent :: Int
            _lhsOpretty :: Doc
            _lhsOisAssociative :: Bool
            _lhsOisLiteral :: Bool
            _lhsOprecedence :: OperatorLevel
            _lhsOcopy :: Expr
            _lhsOcomments :: ([MToken])
            _lhsOisMultiline :: Bool
            _bodyOcomments :: ([MToken])
            _bodyOforceMultiline :: Bool
            _bodyOppconf :: PrettyPrintConfig
            _bodyOstatRegion :: Region
            _bodyIcomments :: ([MToken])
            _bodyIcopy :: Block
            _bodyIisMultiline :: Bool
            _bodyIpretty :: Doc
            _bodyIstatementCount :: Int
            _isMultiline =
              ( _lhsIforceMultiline || _bodyIisMultiline
              )
            _lhsOendsWithPrefixExpression =
              ( False
              )
            _singleLinePretty =
              ( zeroWidthText "function"
                  <> parens _lhsIppconf _emptyParams (printList tok (render _comma) pars_)
                    <-> _bodyIpretty
                    <-> zeroWidthText "end"
              )
            _multilinePretty =
              ( zeroWidthText "function"
                  <> parens _lhsIppconf _emptyParams (printList tok (render _comma) pars_)
                  $+$ _bodyIpretty
                  $+$ indent _lhsIppconf _lhsIindent (zeroWidthText "end")
              )
            _comma =
              ( (if spaceBeforeComma _lhsIppconf then zchr ' ' else empty)
                  <> zchr ','
                  <> (if spaceAfterComma _lhsIppconf then zchr ' ' else empty)
              )
            _emptyParams =
              ( toEmpty $ null pars_
              )
            _bodyOindent =
              ( if _isMultiline then _lhsIindent + 1 else 0
              )
            _lhsOpretty =
              ( if _isMultiline then _multilinePretty else _singleLinePretty
              )
            _lhsOisAssociative =
              ( False
              )
            _lhsOisLiteral =
              ( False
              )
            _lhsOprecedence =
              ( OperatorLevel8
              )
            _copy =
              ( AnonymousFunc pars_ _bodyIcopy
              )
            _lhsOcopy =
              ( _copy
              )
            _lhsOcomments =
              ( _bodyIcomments
              )
            _lhsOisMultiline =
              ( _isMultiline
              )
            _bodyOcomments =
              ( _lhsIcomments
              )
            _bodyOforceMultiline =
              ( _lhsIforceMultiline
              )
            _bodyOppconf =
              ( _lhsIppconf
              )
            _bodyOstatRegion =
              ( _lhsIstatRegion
              )
            (_bodyIcomments, _bodyIcopy, _bodyIisMultiline, _bodyIpretty, _bodyIstatementCount) =
              body_ _bodyOcomments _bodyOforceMultiline _bodyOindent _bodyOppconf _bodyOstatRegion
          in
            (_lhsOcomments, _lhsOcopy, _lhsOendsWithPrefixExpression, _lhsOisAssociative, _lhsOisLiteral, _lhsOisMultiline, _lhsOprecedence, _lhsOpretty)
        )
  )
sem_Expr_APrefixExpr
  :: T_PrefixExp
  -> T_Expr
sem_Expr_APrefixExpr pexpr_ =
  ( \_lhsIcomments
     _lhsIforceMultiline
     _lhsIindent
     _lhsIparentOperatorAssociative
     _lhsIparentOperatorPrecedence
     _lhsIppconf
     _lhsIstatRegion ->
        ( let
            _lhsOpretty :: Doc
            _lhsOendsWithPrefixExpression :: Bool
            _lhsOisMultiline :: Bool
            _lhsOisAssociative :: Bool
            _lhsOisLiteral :: Bool
            _lhsOprecedence :: OperatorLevel
            _lhsOcopy :: Expr
            _lhsOcomments :: ([MToken])
            _pexprOcomments :: ([MToken])
            _pexprOforceMultiline :: Bool
            _pexprOindent :: Int
            _pexprOparentOperatorAssociative :: Bool
            _pexprOparentOperatorPrecedence :: OperatorLevel
            _pexprOppconf :: PrettyPrintConfig
            _pexprIcomments :: ([MToken])
            _pexprIcopy :: PrefixExp
            _pexprIisAssociative :: Bool
            _pexprIisLiteral :: Bool
            _pexprIisMultiline :: Bool
            _pexprIprecedence :: OperatorLevel
            _pexprIpretty :: Doc
            _pexprIstartsWithExprPrefixExpression :: Bool
            _lhsOpretty =
              ( _pexprIpretty
              )
            _lhsOendsWithPrefixExpression =
              ( True
              )
            _lhsOisMultiline =
              ( _pexprIisMultiline
              )
            _lhsOisAssociative =
              ( _pexprIisAssociative
              )
            _lhsOisLiteral =
              ( _pexprIisLiteral
              )
            _lhsOprecedence =
              ( _pexprIprecedence
              )
            _copy =
              ( APrefixExpr _pexprIcopy
              )
            _lhsOcopy =
              ( _copy
              )
            _lhsOcomments =
              ( _pexprIcomments
              )
            _pexprOcomments =
              ( _lhsIcomments
              )
            _pexprOforceMultiline =
              ( _lhsIforceMultiline
              )
            _pexprOindent =
              ( _lhsIindent
              )
            _pexprOparentOperatorAssociative =
              ( _lhsIparentOperatorAssociative
              )
            _pexprOparentOperatorPrecedence =
              ( _lhsIparentOperatorPrecedence
              )
            _pexprOppconf =
              ( _lhsIppconf
              )
            (_pexprIcomments, _pexprIcopy, _pexprIisAssociative, _pexprIisLiteral, _pexprIisMultiline, _pexprIprecedence, _pexprIpretty, _pexprIstartsWithExprPrefixExpression) =
              pexpr_ _pexprOcomments _pexprOforceMultiline _pexprOindent _pexprOparentOperatorAssociative _pexprOparentOperatorPrecedence _pexprOppconf
          in
            (_lhsOcomments, _lhsOcopy, _lhsOendsWithPrefixExpression, _lhsOisAssociative, _lhsOisLiteral, _lhsOisMultiline, _lhsOprecedence, _lhsOpretty)
        )
  )
sem_Expr_ATableConstructor
  :: T_FieldList
  -> T_Expr
sem_Expr_ATableConstructor fields_ =
  ( \_lhsIcomments
     _lhsIforceMultiline
     _lhsIindent
     _lhsIparentOperatorAssociative
     _lhsIparentOperatorPrecedence
     _lhsIppconf
     _lhsIstatRegion ->
        ( let
            _lhsOpretty :: Doc
            _lhsOisLiteral :: Bool
            _lhsOendsWithPrefixExpression :: Bool
            _fieldsOindent :: Int
            _fieldsOsomeElementsInListAreMultiline :: Bool
            _lhsOisAssociative :: Bool
            _lhsOprecedence :: OperatorLevel
            _lhsOcopy :: Expr
            _lhsOcomments :: ([MToken])
            _lhsOisMultiline :: Bool
            _fieldsOcomments :: ([MToken])
            _fieldsOforceMultiline :: Bool
            _fieldsOppconf :: PrettyPrintConfig
            _fieldsIcomments :: ([MToken])
            _fieldsIcopy :: FieldList
            _fieldsIisMultiline :: Bool
            _fieldsIisNil :: Bool
            _fieldsIpretty :: Doc
            _lhsOpretty =
              ( if _isMultiline then _prettyMulti else _prettySingle
              )
            _isMultiline =
              ( _lhsIforceMultiline || _fieldsIisMultiline
              )
            _lhsOisLiteral =
              ( True
              )
            _lhsOendsWithPrefixExpression =
              ( False
              )
            _prettyMulti =
              ( zchr '{' $+$ _fieldsIpretty $+$ indent _lhsIppconf _lhsIindent (zchr '}')
              )
            _prettySingle =
              ( braces _lhsIppconf _emptyContents _fieldsIpretty
              )
            _emptyContents =
              ( toEmpty $ null _fieldsIcopy
              )
            _fieldsOindent =
              ( _lhsIindent + (if _fieldsIisMultiline then 1 else 0)
              )
            _fieldsOsomeElementsInListAreMultiline =
              ( False
              )
            _lhsOisAssociative =
              ( False
              )
            _lhsOprecedence =
              ( OperatorLevel8
              )
            _copy =
              ( ATableConstructor _fieldsIcopy
              )
            _lhsOcopy =
              ( _copy
              )
            _lhsOcomments =
              ( _fieldsIcomments
              )
            _lhsOisMultiline =
              ( _isMultiline
              )
            _fieldsOcomments =
              ( _lhsIcomments
              )
            _fieldsOforceMultiline =
              ( _lhsIforceMultiline
              )
            _fieldsOppconf =
              ( _lhsIppconf
              )
            (_fieldsIcomments, _fieldsIcopy, _fieldsIisMultiline, _fieldsIisNil, _fieldsIpretty) =
              fields_ _fieldsOcomments _fieldsOforceMultiline _fieldsOindent _fieldsOppconf _fieldsOsomeElementsInListAreMultiline
          in
            (_lhsOcomments, _lhsOcopy, _lhsOendsWithPrefixExpression, _lhsOisAssociative, _lhsOisLiteral, _lhsOisMultiline, _lhsOprecedence, _lhsOpretty)
        )
  )
sem_Expr_BinOpExpr
  :: T_BinOp
  -> T_MExpr
  -> T_MExpr
  -> T_Expr
sem_Expr_BinOpExpr op_ left_ right_ =
  ( \_lhsIcomments
     _lhsIforceMultiline
     _lhsIindent
     _lhsIparentOperatorAssociative
     _lhsIparentOperatorPrecedence
     _lhsIppconf
     _lhsIstatRegion ->
        ( let
            _lhsOpretty :: Doc
            _lhsOendsWithPrefixExpression :: Bool
            _lhsOprecedence :: OperatorLevel
            _lhsOisMultiline :: Bool
            _leftOparentOperatorPrecedence :: OperatorLevel
            _rightOparentOperatorPrecedence :: OperatorLevel
            _leftOparentOperatorAssociative :: Bool
            _rightOparentOperatorAssociative :: Bool
            _lhsOisAssociative :: Bool
            _lhsOisLiteral :: Bool
            _lhsOcopy :: Expr
            _lhsOcomments :: ([MToken])
            _opOcomments :: ([MToken])
            _opOindent :: Int
            _opOppconf :: PrettyPrintConfig
            _leftOcomments :: ([MToken])
            _leftOforceMultiline :: Bool
            _leftOindent :: Int
            _leftOppconf :: PrettyPrintConfig
            _rightOcomments :: ([MToken])
            _rightOforceMultiline :: Bool
            _rightOindent :: Int
            _rightOppconf :: PrettyPrintConfig
            _opIcomments :: ([MToken])
            _opIcopy :: BinOp
            _opIisAssociative :: Bool
            _opIisMultiline :: Bool
            _opIprecedence :: OperatorLevel
            _opIpretty :: Doc
            _leftIcomments :: ([MToken])
            _leftIcopy :: MExpr
            _leftIendsWithPrefixExpression :: Bool
            _leftIisAssociative :: Bool
            _leftIisLiteral :: Bool
            _leftIisMultiline :: Bool
            _leftIpos :: Region
            _leftIprecedence :: OperatorLevel
            _leftIpretty :: Doc
            _rightIcomments :: ([MToken])
            _rightIcopy :: MExpr
            _rightIendsWithPrefixExpression :: Bool
            _rightIisAssociative :: Bool
            _rightIisLiteral :: Bool
            _rightIisMultiline :: Bool
            _rightIpos :: Region
            _rightIprecedence :: OperatorLevel
            _rightIpretty :: Doc
            _lhsOpretty =
              ( _leftIpretty <-> _opIpretty <-> _rightIpretty
              )
            _lhsOendsWithPrefixExpression =
              ( _rightIendsWithPrefixExpression
              )
            _lhsOprecedence =
              ( min _opIprecedence $ min _leftIprecedence _rightIprecedence
              )
            _lhsOisMultiline =
              ( _leftIisMultiline || _rightIisMultiline
              )
            _leftOparentOperatorPrecedence =
              ( _opIprecedence
              )
            _rightOparentOperatorPrecedence =
              ( _opIprecedence
              )
            _leftOparentOperatorAssociative =
              ( _opIisAssociative
              )
            _rightOparentOperatorAssociative =
              ( _opIisAssociative
              )
            _lhsOisAssociative =
              ( _opIisAssociative && _leftIisAssociative && _rightIisAssociative
              )
            _lhsOisLiteral =
              ( ((\_ _ -> False) _leftIisLiteral _rightIisLiteral)
              )
            _copy =
              ( BinOpExpr _opIcopy _leftIcopy _rightIcopy
              )
            _lhsOcopy =
              ( _copy
              )
            _lhsOcomments =
              ( _rightIcomments
              )
            _opOcomments =
              ( _lhsIcomments
              )
            _opOindent =
              ( _lhsIindent
              )
            _opOppconf =
              ( _lhsIppconf
              )
            _leftOcomments =
              ( _opIcomments
              )
            _leftOforceMultiline =
              ( _lhsIforceMultiline
              )
            _leftOindent =
              ( _lhsIindent
              )
            _leftOppconf =
              ( _lhsIppconf
              )
            _rightOcomments =
              ( _leftIcomments
              )
            _rightOforceMultiline =
              ( _lhsIforceMultiline
              )
            _rightOindent =
              ( _lhsIindent
              )
            _rightOppconf =
              ( _lhsIppconf
              )
            (_opIcomments, _opIcopy, _opIisAssociative, _opIisMultiline, _opIprecedence, _opIpretty) =
              op_ _opOcomments _opOindent _opOppconf
            (_leftIcomments, _leftIcopy, _leftIendsWithPrefixExpression, _leftIisAssociative, _leftIisLiteral, _leftIisMultiline, _leftIpos, _leftIprecedence, _leftIpretty) =
              left_ _leftOcomments _leftOforceMultiline _leftOindent _leftOparentOperatorAssociative _leftOparentOperatorPrecedence _leftOppconf
            (_rightIcomments, _rightIcopy, _rightIendsWithPrefixExpression, _rightIisAssociative, _rightIisLiteral, _rightIisMultiline, _rightIpos, _rightIprecedence, _rightIpretty) =
              right_ _rightOcomments _rightOforceMultiline _rightOindent _rightOparentOperatorAssociative _rightOparentOperatorPrecedence _rightOppconf
          in
            (_lhsOcomments, _lhsOcopy, _lhsOendsWithPrefixExpression, _lhsOisAssociative, _lhsOisLiteral, _lhsOisMultiline, _lhsOprecedence, _lhsOpretty)
        )
  )
sem_Expr_UnOpExpr
  :: T_UnOp
  -> T_MExpr
  -> T_Expr
sem_Expr_UnOpExpr op_ right_ =
  ( \_lhsIcomments
     _lhsIforceMultiline
     _lhsIindent
     _lhsIparentOperatorAssociative
     _lhsIparentOperatorPrecedence
     _lhsIppconf
     _lhsIstatRegion ->
        ( let
            _lhsOpretty :: Doc
            _lhsOprecedence :: OperatorLevel
            _lhsOendsWithPrefixExpression :: Bool
            _lhsOisMultiline :: Bool
            _rightOparentOperatorPrecedence :: OperatorLevel
            _lhsOisAssociative :: Bool
            _lhsOisLiteral :: Bool
            _lhsOcopy :: Expr
            _lhsOcomments :: ([MToken])
            _opOcomments :: ([MToken])
            _opOindent :: Int
            _opOppconf :: PrettyPrintConfig
            _rightOcomments :: ([MToken])
            _rightOforceMultiline :: Bool
            _rightOindent :: Int
            _rightOparentOperatorAssociative :: Bool
            _rightOppconf :: PrettyPrintConfig
            _opIcomments :: ([MToken])
            _opIcopy :: UnOp
            _opIisMultiline :: Bool
            _opIpretty :: Doc
            _rightIcomments :: ([MToken])
            _rightIcopy :: MExpr
            _rightIendsWithPrefixExpression :: Bool
            _rightIisAssociative :: Bool
            _rightIisLiteral :: Bool
            _rightIisMultiline :: Bool
            _rightIpos :: Region
            _rightIprecedence :: OperatorLevel
            _rightIpretty :: Doc
            _lhsOpretty =
              ( _opIpretty <> _rightIpretty
              )
            _lhsOprecedence =
              ( min _rightIprecedence OperatorLevel7
              )
            _lhsOendsWithPrefixExpression =
              ( _rightIendsWithPrefixExpression
              )
            _lhsOisMultiline =
              ( _opIisMultiline || _rightIisMultiline
              )
            _rightOparentOperatorPrecedence =
              ( OperatorLevel7
              )
            _lhsOisAssociative =
              ( _rightIisAssociative
              )
            _lhsOisLiteral =
              ( _rightIisLiteral
              )
            _copy =
              ( UnOpExpr _opIcopy _rightIcopy
              )
            _lhsOcopy =
              ( _copy
              )
            _lhsOcomments =
              ( _rightIcomments
              )
            _opOcomments =
              ( _lhsIcomments
              )
            _opOindent =
              ( _lhsIindent
              )
            _opOppconf =
              ( _lhsIppconf
              )
            _rightOcomments =
              ( _opIcomments
              )
            _rightOforceMultiline =
              ( _lhsIforceMultiline
              )
            _rightOindent =
              ( _lhsIindent
              )
            _rightOparentOperatorAssociative =
              ( _lhsIparentOperatorAssociative
              )
            _rightOppconf =
              ( _lhsIppconf
              )
            (_opIcomments, _opIcopy, _opIisMultiline, _opIpretty) =
              op_ _opOcomments _opOindent _opOppconf
            (_rightIcomments, _rightIcopy, _rightIendsWithPrefixExpression, _rightIisAssociative, _rightIisLiteral, _rightIisMultiline, _rightIpos, _rightIprecedence, _rightIpretty) =
              right_ _rightOcomments _rightOforceMultiline _rightOindent _rightOparentOperatorAssociative _rightOparentOperatorPrecedence _rightOppconf
          in
            (_lhsOcomments, _lhsOcopy, _lhsOendsWithPrefixExpression, _lhsOisAssociative, _lhsOisLiteral, _lhsOisMultiline, _lhsOprecedence, _lhsOpretty)
        )
  )

-- ExprSuffixList ----------------------------------------------
-- cata
sem_ExprSuffixList
  :: ExprSuffixList
  -> T_ExprSuffixList
sem_ExprSuffixList list =
  (Prelude.foldr sem_ExprSuffixList_Cons sem_ExprSuffixList_Nil (Prelude.map sem_PFExprSuffix list))

-- semantic domain
type T_ExprSuffixList =
  ([MToken])
  -> Bool
  -> Int
  -> PrettyPrintConfig
  -> (([MToken]), ExprSuffixList, Bool, Bool, OperatorLevel, Doc)
data Inh_ExprSuffixList = Inh_ExprSuffixList {comments_Inh_ExprSuffixList :: ([MToken]), forceMultiline_Inh_ExprSuffixList :: Bool, indent_Inh_ExprSuffixList :: Int, ppconf_Inh_ExprSuffixList :: PrettyPrintConfig}
data Syn_ExprSuffixList = Syn_ExprSuffixList {comments_Syn_ExprSuffixList :: ([MToken]), copy_Syn_ExprSuffixList :: ExprSuffixList, isAssociative_Syn_ExprSuffixList :: Bool, isMultiline_Syn_ExprSuffixList :: Bool, precedence_Syn_ExprSuffixList :: OperatorLevel, pretty_Syn_ExprSuffixList :: Doc}
wrap_ExprSuffixList
  :: T_ExprSuffixList
  -> Inh_ExprSuffixList
  -> Syn_ExprSuffixList
wrap_ExprSuffixList sem (Inh_ExprSuffixList _lhsIcomments _lhsIforceMultiline _lhsIindent _lhsIppconf) =
  ( let
      (_lhsOcomments, _lhsOcopy, _lhsOisAssociative, _lhsOisMultiline, _lhsOprecedence, _lhsOpretty) = sem _lhsIcomments _lhsIforceMultiline _lhsIindent _lhsIppconf
    in
      (Syn_ExprSuffixList _lhsOcomments _lhsOcopy _lhsOisAssociative _lhsOisMultiline _lhsOprecedence _lhsOpretty)
  )
sem_ExprSuffixList_Cons
  :: T_PFExprSuffix
  -> T_ExprSuffixList
  -> T_ExprSuffixList
sem_ExprSuffixList_Cons hd_ tl_ =
  ( \_lhsIcomments
     _lhsIforceMultiline
     _lhsIindent
     _lhsIppconf ->
        ( let
            _lhsOpretty :: Doc
            _lhsOisMultiline :: Bool
            _lhsOisAssociative :: Bool
            _lhsOprecedence :: OperatorLevel
            _lhsOcopy :: ExprSuffixList
            _lhsOcomments :: ([MToken])
            _hdOcomments :: ([MToken])
            _hdOforceMultiline :: Bool
            _hdOindent :: Int
            _hdOppconf :: PrettyPrintConfig
            _tlOcomments :: ([MToken])
            _tlOforceMultiline :: Bool
            _tlOindent :: Int
            _tlOppconf :: PrettyPrintConfig
            _hdIcomments :: ([MToken])
            _hdIcopy :: PFExprSuffix
            _hdIisAssociative :: Bool
            _hdIisMultiline :: Bool
            _hdIprecedence :: OperatorLevel
            _hdIpretty :: Doc
            _tlIcomments :: ([MToken])
            _tlIcopy :: ExprSuffixList
            _tlIisAssociative :: Bool
            _tlIisMultiline :: Bool
            _tlIprecedence :: OperatorLevel
            _tlIpretty :: Doc
            _lhsOpretty =
              ( _hdIpretty <> _tlIpretty
              )
            _lhsOisMultiline =
              ( _hdIisMultiline || _tlIisMultiline
              )
            _lhsOisAssociative =
              ( _hdIisAssociative && _tlIisAssociative
              )
            _lhsOprecedence =
              ( (min _hdIprecedence _tlIprecedence)
              )
            _copy =
              ( (:) _hdIcopy _tlIcopy
              )
            _lhsOcopy =
              ( _copy
              )
            _lhsOcomments =
              ( _tlIcomments
              )
            _hdOcomments =
              ( _lhsIcomments
              )
            _hdOforceMultiline =
              ( _lhsIforceMultiline
              )
            _hdOindent =
              ( _lhsIindent
              )
            _hdOppconf =
              ( _lhsIppconf
              )
            _tlOcomments =
              ( _hdIcomments
              )
            _tlOforceMultiline =
              ( _lhsIforceMultiline
              )
            _tlOindent =
              ( _lhsIindent
              )
            _tlOppconf =
              ( _lhsIppconf
              )
            (_hdIcomments, _hdIcopy, _hdIisAssociative, _hdIisMultiline, _hdIprecedence, _hdIpretty) =
              hd_ _hdOcomments _hdOforceMultiline _hdOindent _hdOppconf
            (_tlIcomments, _tlIcopy, _tlIisAssociative, _tlIisMultiline, _tlIprecedence, _tlIpretty) =
              tl_ _tlOcomments _tlOforceMultiline _tlOindent _tlOppconf
          in
            (_lhsOcomments, _lhsOcopy, _lhsOisAssociative, _lhsOisMultiline, _lhsOprecedence, _lhsOpretty)
        )
  )
sem_ExprSuffixList_Nil :: T_ExprSuffixList
sem_ExprSuffixList_Nil =
  ( \_lhsIcomments
     _lhsIforceMultiline
     _lhsIindent
     _lhsIppconf ->
        ( let
            _lhsOpretty :: Doc
            _lhsOisMultiline :: Bool
            _lhsOisAssociative :: Bool
            _lhsOprecedence :: OperatorLevel
            _lhsOcopy :: ExprSuffixList
            _lhsOcomments :: ([MToken])
            _lhsOpretty =
              ( empty
              )
            _lhsOisMultiline =
              ( False
              )
            _lhsOisAssociative =
              ( False
              )
            _lhsOprecedence =
              ( OperatorLevel8
              )
            _copy =
              ( []
              )
            _lhsOcopy =
              ( _copy
              )
            _lhsOcomments =
              ( _lhsIcomments
              )
          in
            (_lhsOcomments, _lhsOcopy, _lhsOisAssociative, _lhsOisMultiline, _lhsOprecedence, _lhsOpretty)
        )
  )

-- Field -------------------------------------------------------
-- cata
sem_Field
  :: Field
  -> T_Field
sem_Field (ExprField _key _value _sep) =
  (sem_Field_ExprField (sem_MExpr _key) (sem_MExpr _value) (sem_FieldSep _sep))
sem_Field (NamedField _key _value _sep) =
  (sem_Field_NamedField _key (sem_MExpr _value) (sem_FieldSep _sep))
sem_Field (UnnamedField _value _sep) =
  (sem_Field_UnnamedField (sem_MExpr _value) (sem_FieldSep _sep))

-- semantic domain
type T_Field =
  ([MToken])
  -> Bool
  -> Int
  -> PrettyPrintConfig
  -> (([MToken]), Field, Bool, Bool, Region, Doc)
data Inh_Field = Inh_Field {comments_Inh_Field :: ([MToken]), forceMultiline_Inh_Field :: Bool, indent_Inh_Field :: Int, ppconf_Inh_Field :: PrettyPrintConfig}
data Syn_Field = Syn_Field {comments_Syn_Field :: ([MToken]), copy_Syn_Field :: Field, isMultiline_Syn_Field :: Bool, isSemiColon_Syn_Field :: Bool, pos_Syn_Field :: Region, pretty_Syn_Field :: Doc}
wrap_Field
  :: T_Field
  -> Inh_Field
  -> Syn_Field
wrap_Field sem (Inh_Field _lhsIcomments _lhsIforceMultiline _lhsIindent _lhsIppconf) =
  ( let
      (_lhsOcomments, _lhsOcopy, _lhsOisMultiline, _lhsOisSemiColon, _lhsOpos, _lhsOpretty) = sem _lhsIcomments _lhsIforceMultiline _lhsIindent _lhsIppconf
    in
      (Syn_Field _lhsOcomments _lhsOcopy _lhsOisMultiline _lhsOisSemiColon _lhsOpos _lhsOpretty)
  )
sem_Field_ExprField
  :: T_MExpr
  -> T_MExpr
  -> T_FieldSep
  -> T_Field
sem_Field_ExprField key_ value_ sep_ =
  ( \_lhsIcomments
     _lhsIforceMultiline
     _lhsIindent
     _lhsIppconf ->
        ( let
            _lhsOpretty :: Doc
            _lhsOisMultiline :: Bool
            _keyOparentOperatorPrecedence :: OperatorLevel
            _keyOparentOperatorAssociative :: Bool
            _valueOparentOperatorPrecedence :: OperatorLevel
            _valueOparentOperatorAssociative :: Bool
            _lhsOisSemiColon :: Bool
            _lhsOcopy :: Field
            _lhsOcomments :: ([MToken])
            _lhsOpos :: Region
            _keyOcomments :: ([MToken])
            _keyOforceMultiline :: Bool
            _keyOindent :: Int
            _keyOppconf :: PrettyPrintConfig
            _valueOcomments :: ([MToken])
            _valueOforceMultiline :: Bool
            _valueOindent :: Int
            _valueOppconf :: PrettyPrintConfig
            _sepOindent :: Int
            _sepOppconf :: PrettyPrintConfig
            _keyIcomments :: ([MToken])
            _keyIcopy :: MExpr
            _keyIendsWithPrefixExpression :: Bool
            _keyIisAssociative :: Bool
            _keyIisLiteral :: Bool
            _keyIisMultiline :: Bool
            _keyIpos :: Region
            _keyIprecedence :: OperatorLevel
            _keyIpretty :: Doc
            _valueIcomments :: ([MToken])
            _valueIcopy :: MExpr
            _valueIendsWithPrefixExpression :: Bool
            _valueIisAssociative :: Bool
            _valueIisLiteral :: Bool
            _valueIisMultiline :: Bool
            _valueIpos :: Region
            _valueIprecedence :: OperatorLevel
            _valueIpretty :: Doc
            _sepIcopy :: FieldSep
            _sepIisMultiline :: Bool
            _sepIisSemiColon :: Bool
            _sepIpretty :: Doc
            _lhsOpretty =
              ( brackets _lhsIppconf _keyIpretty <-> zchr '=' <-> _valueIpretty <> _sepIpretty
              )
            _lhsOisMultiline =
              ( True
              )
            _keyOparentOperatorPrecedence =
              ( TopLevelExpression
              )
            _keyOparentOperatorAssociative =
              ( True
              )
            _valueOparentOperatorPrecedence =
              ( TopLevelExpression
              )
            _valueOparentOperatorAssociative =
              ( True
              )
            _lhsOisSemiColon =
              ( _sepIisSemiColon
              )
            _copy =
              ( ExprField _keyIcopy _valueIcopy _sepIcopy
              )
            _lhsOcopy =
              ( _copy
              )
            _lhsOcomments =
              ( _valueIcomments
              )
            _lhsOpos =
              ( _valueIpos
              )
            _keyOcomments =
              ( _lhsIcomments
              )
            _keyOforceMultiline =
              ( _lhsIforceMultiline
              )
            _keyOindent =
              ( _lhsIindent
              )
            _keyOppconf =
              ( _lhsIppconf
              )
            _valueOcomments =
              ( _keyIcomments
              )
            _valueOforceMultiline =
              ( _lhsIforceMultiline
              )
            _valueOindent =
              ( _lhsIindent
              )
            _valueOppconf =
              ( _lhsIppconf
              )
            _sepOindent =
              ( _lhsIindent
              )
            _sepOppconf =
              ( _lhsIppconf
              )
            (_keyIcomments, _keyIcopy, _keyIendsWithPrefixExpression, _keyIisAssociative, _keyIisLiteral, _keyIisMultiline, _keyIpos, _keyIprecedence, _keyIpretty) =
              key_ _keyOcomments _keyOforceMultiline _keyOindent _keyOparentOperatorAssociative _keyOparentOperatorPrecedence _keyOppconf
            (_valueIcomments, _valueIcopy, _valueIendsWithPrefixExpression, _valueIisAssociative, _valueIisLiteral, _valueIisMultiline, _valueIpos, _valueIprecedence, _valueIpretty) =
              value_ _valueOcomments _valueOforceMultiline _valueOindent _valueOparentOperatorAssociative _valueOparentOperatorPrecedence _valueOppconf
            (_sepIcopy, _sepIisMultiline, _sepIisSemiColon, _sepIpretty) =
              sep_ _sepOindent _sepOppconf
          in
            (_lhsOcomments, _lhsOcopy, _lhsOisMultiline, _lhsOisSemiColon, _lhsOpos, _lhsOpretty)
        )
  )
sem_Field_NamedField
  :: MToken
  -> T_MExpr
  -> T_FieldSep
  -> T_Field
sem_Field_NamedField key_ value_ sep_ =
  ( \_lhsIcomments
     _lhsIforceMultiline
     _lhsIindent
     _lhsIppconf ->
        ( let
            _lhsOpretty :: Doc
            _lhsOisMultiline :: Bool
            _valueOparentOperatorPrecedence :: OperatorLevel
            _valueOparentOperatorAssociative :: Bool
            _lhsOisSemiColon :: Bool
            _lhsOcopy :: Field
            _lhsOcomments :: ([MToken])
            _lhsOpos :: Region
            _valueOcomments :: ([MToken])
            _valueOforceMultiline :: Bool
            _valueOindent :: Int
            _valueOppconf :: PrettyPrintConfig
            _sepOindent :: Int
            _sepOppconf :: PrettyPrintConfig
            _valueIcomments :: ([MToken])
            _valueIcopy :: MExpr
            _valueIendsWithPrefixExpression :: Bool
            _valueIisAssociative :: Bool
            _valueIisLiteral :: Bool
            _valueIisMultiline :: Bool
            _valueIpos :: Region
            _valueIprecedence :: OperatorLevel
            _valueIpretty :: Doc
            _sepIcopy :: FieldSep
            _sepIisMultiline :: Bool
            _sepIisSemiColon :: Bool
            _sepIpretty :: Doc
            _lhsOpretty =
              ( tok key_ <-> zchr '=' <-> _valueIpretty <> _sepIpretty
              )
            _lhsOisMultiline =
              ( True
              )
            _valueOparentOperatorPrecedence =
              ( TopLevelExpression
              )
            _valueOparentOperatorAssociative =
              ( True
              )
            _lhsOisSemiColon =
              ( _sepIisSemiColon
              )
            _copy =
              ( NamedField key_ _valueIcopy _sepIcopy
              )
            _lhsOcopy =
              ( _copy
              )
            _lhsOcomments =
              ( _valueIcomments
              )
            _lhsOpos =
              ( _valueIpos
              )
            _valueOcomments =
              ( _lhsIcomments
              )
            _valueOforceMultiline =
              ( _lhsIforceMultiline
              )
            _valueOindent =
              ( _lhsIindent
              )
            _valueOppconf =
              ( _lhsIppconf
              )
            _sepOindent =
              ( _lhsIindent
              )
            _sepOppconf =
              ( _lhsIppconf
              )
            (_valueIcomments, _valueIcopy, _valueIendsWithPrefixExpression, _valueIisAssociative, _valueIisLiteral, _valueIisMultiline, _valueIpos, _valueIprecedence, _valueIpretty) =
              value_ _valueOcomments _valueOforceMultiline _valueOindent _valueOparentOperatorAssociative _valueOparentOperatorPrecedence _valueOppconf
            (_sepIcopy, _sepIisMultiline, _sepIisSemiColon, _sepIpretty) =
              sep_ _sepOindent _sepOppconf
          in
            (_lhsOcomments, _lhsOcopy, _lhsOisMultiline, _lhsOisSemiColon, _lhsOpos, _lhsOpretty)
        )
  )
sem_Field_UnnamedField
  :: T_MExpr
  -> T_FieldSep
  -> T_Field
sem_Field_UnnamedField value_ sep_ =
  ( \_lhsIcomments
     _lhsIforceMultiline
     _lhsIindent
     _lhsIppconf ->
        ( let
            _lhsOpretty :: Doc
            _lhsOisMultiline :: Bool
            _valueOparentOperatorPrecedence :: OperatorLevel
            _valueOparentOperatorAssociative :: Bool
            _lhsOisSemiColon :: Bool
            _lhsOcopy :: Field
            _lhsOcomments :: ([MToken])
            _lhsOpos :: Region
            _valueOcomments :: ([MToken])
            _valueOforceMultiline :: Bool
            _valueOindent :: Int
            _valueOppconf :: PrettyPrintConfig
            _sepOindent :: Int
            _sepOppconf :: PrettyPrintConfig
            _valueIcomments :: ([MToken])
            _valueIcopy :: MExpr
            _valueIendsWithPrefixExpression :: Bool
            _valueIisAssociative :: Bool
            _valueIisLiteral :: Bool
            _valueIisMultiline :: Bool
            _valueIpos :: Region
            _valueIprecedence :: OperatorLevel
            _valueIpretty :: Doc
            _sepIcopy :: FieldSep
            _sepIisMultiline :: Bool
            _sepIisSemiColon :: Bool
            _sepIpretty :: Doc
            _lhsOpretty =
              ( _valueIpretty <> _sepIpretty
              )
            _lhsOisMultiline =
              ( _valueIisMultiline || _sepIisMultiline
              )
            _valueOparentOperatorPrecedence =
              ( TopLevelExpression
              )
            _valueOparentOperatorAssociative =
              ( True
              )
            _lhsOisSemiColon =
              ( _sepIisSemiColon
              )
            _copy =
              ( UnnamedField _valueIcopy _sepIcopy
              )
            _lhsOcopy =
              ( _copy
              )
            _lhsOcomments =
              ( _valueIcomments
              )
            _lhsOpos =
              ( _valueIpos
              )
            _valueOcomments =
              ( _lhsIcomments
              )
            _valueOforceMultiline =
              ( _lhsIforceMultiline
              )
            _valueOindent =
              ( _lhsIindent
              )
            _valueOppconf =
              ( _lhsIppconf
              )
            _sepOindent =
              ( _lhsIindent
              )
            _sepOppconf =
              ( _lhsIppconf
              )
            (_valueIcomments, _valueIcopy, _valueIendsWithPrefixExpression, _valueIisAssociative, _valueIisLiteral, _valueIisMultiline, _valueIpos, _valueIprecedence, _valueIpretty) =
              value_ _valueOcomments _valueOforceMultiline _valueOindent _valueOparentOperatorAssociative _valueOparentOperatorPrecedence _valueOppconf
            (_sepIcopy, _sepIisMultiline, _sepIisSemiColon, _sepIpretty) =
              sep_ _sepOindent _sepOppconf
          in
            (_lhsOcomments, _lhsOcopy, _lhsOisMultiline, _lhsOisSemiColon, _lhsOpos, _lhsOpretty)
        )
  )

-- FieldList ---------------------------------------------------
-- cata
sem_FieldList
  :: FieldList
  -> T_FieldList
sem_FieldList list =
  (Prelude.foldr sem_FieldList_Cons sem_FieldList_Nil (Prelude.map sem_Field list))

-- semantic domain
type T_FieldList =
  ([MToken])
  -> Bool
  -> Int
  -> PrettyPrintConfig
  -> Bool
  -> (([MToken]), FieldList, Bool, Bool, Doc)
data Inh_FieldList = Inh_FieldList {comments_Inh_FieldList :: ([MToken]), forceMultiline_Inh_FieldList :: Bool, indent_Inh_FieldList :: Int, ppconf_Inh_FieldList :: PrettyPrintConfig, someElementsInListAreMultiline_Inh_FieldList :: Bool}
data Syn_FieldList = Syn_FieldList {comments_Syn_FieldList :: ([MToken]), copy_Syn_FieldList :: FieldList, isMultiline_Syn_FieldList :: Bool, isNil_Syn_FieldList :: Bool, pretty_Syn_FieldList :: Doc}
wrap_FieldList
  :: T_FieldList
  -> Inh_FieldList
  -> Syn_FieldList
wrap_FieldList sem (Inh_FieldList _lhsIcomments _lhsIforceMultiline _lhsIindent _lhsIppconf _lhsIsomeElementsInListAreMultiline) =
  ( let
      (_lhsOcomments, _lhsOcopy, _lhsOisMultiline, _lhsOisNil, _lhsOpretty) = sem _lhsIcomments _lhsIforceMultiline _lhsIindent _lhsIppconf _lhsIsomeElementsInListAreMultiline
    in
      (Syn_FieldList _lhsOcomments _lhsOcopy _lhsOisMultiline _lhsOisNil _lhsOpretty)
  )
sem_FieldList_Cons
  :: T_Field
  -> T_FieldList
  -> T_FieldList
sem_FieldList_Cons hd_ tl_ =
  ( \_lhsIcomments
     _lhsIforceMultiline
     _lhsIindent
     _lhsIppconf
     _lhsIsomeElementsInListAreMultiline ->
        ( let
            _lhsOpretty :: Doc
            _lhsOisNil :: Bool
            _tlOsomeElementsInListAreMultiline :: Bool
            _hdOcomments :: ([MToken])
            _tlOcomments :: ([MToken])
            _lhsOcomments :: ([MToken])
            _lhsOcopy :: FieldList
            _lhsOisMultiline :: Bool
            _hdOforceMultiline :: Bool
            _hdOindent :: Int
            _hdOppconf :: PrettyPrintConfig
            _tlOforceMultiline :: Bool
            _tlOindent :: Int
            _tlOppconf :: PrettyPrintConfig
            _hdIcomments :: ([MToken])
            _hdIcopy :: Field
            _hdIisMultiline :: Bool
            _hdIisSemiColon :: Bool
            _hdIpos :: Region
            _hdIpretty :: Doc
            _tlIcomments :: ([MToken])
            _tlIcopy :: FieldList
            _tlIisMultiline :: Bool
            _tlIisNil :: Bool
            _tlIpretty :: Doc
            _lhsOpretty =
              ( if _isMultiline
                  then
                    renderMLComments _lhsIppconf _lhsIindent (fst _commentsBefore)
                      $+$ indent _lhsIppconf _lhsIindent _hdIpretty
                        <-> renderSLComments _lhsIppconf _lhsIindent (fst _commentsAfter)
                      $+$ _tlIpretty
                  else
                    _hdIpretty
                      `_optionalSpaceAfterSep` _tlIpretty
              )
            _lhsOisNil =
              ( False
              )
            _optionalSpaceAfterSep =
              ( if spaceAfterComma _lhsIppconf then (<->) else (<>)
              )
            _isMultiline =
              ( _lhsIforceMultiline
                  || _hdIisMultiline
                  || _tlIisMultiline
                  || _lhsIsomeElementsInListAreMultiline
                  || not (null $ fst _commentsBefore)
                  || not (null $ fst _commentsAfter)
              )
            _tlOsomeElementsInListAreMultiline =
              ( _lhsIsomeElementsInListAreMultiline
                  || _hdIisMultiline
                  || not (null $ fst _commentsBefore)
                  || not (null $ fst _commentsAfter)
              )
            _commentsBefore =
              ( span (\(MToken pos _) -> pos `before` _hdIpos) _lhsIcomments
              )
            _hdOcomments =
              ( snd _commentsBefore
              )
            _commentsAfter =
              ( span (\(MToken pos _) -> pos `beforeOrOnLine` _hdIpos) _hdIcomments
              )
            _tlOcomments =
              ( snd _commentsAfter
              )
            _lhsOcomments =
              ( _tlIcomments
              )
            _copy =
              ( (:) _hdIcopy _tlIcopy
              )
            _lhsOcopy =
              ( _copy
              )
            _lhsOisMultiline =
              ( _isMultiline
              )
            _hdOforceMultiline =
              ( _lhsIforceMultiline
              )
            _hdOindent =
              ( _lhsIindent
              )
            _hdOppconf =
              ( _lhsIppconf
              )
            _tlOforceMultiline =
              ( _lhsIforceMultiline
              )
            _tlOindent =
              ( _lhsIindent
              )
            _tlOppconf =
              ( _lhsIppconf
              )
            (_hdIcomments, _hdIcopy, _hdIisMultiline, _hdIisSemiColon, _hdIpos, _hdIpretty) =
              hd_ _hdOcomments _hdOforceMultiline _hdOindent _hdOppconf
            (_tlIcomments, _tlIcopy, _tlIisMultiline, _tlIisNil, _tlIpretty) =
              tl_ _tlOcomments _tlOforceMultiline _tlOindent _tlOppconf _tlOsomeElementsInListAreMultiline
          in
            (_lhsOcomments, _lhsOcopy, _lhsOisMultiline, _lhsOisNil, _lhsOpretty)
        )
  )
sem_FieldList_Nil :: T_FieldList
sem_FieldList_Nil =
  ( \_lhsIcomments
     _lhsIforceMultiline
     _lhsIindent
     _lhsIppconf
     _lhsIsomeElementsInListAreMultiline ->
        ( let
            _lhsOpretty :: Doc
            _lhsOisNil :: Bool
            _lhsOisMultiline :: Bool
            _lhsOcopy :: FieldList
            _lhsOcomments :: ([MToken])
            _lhsOpretty =
              ( empty
              )
            _lhsOisNil =
              ( True
              )
            _lhsOisMultiline =
              ( False
              )
            _copy =
              ( []
              )
            _lhsOcopy =
              ( _copy
              )
            _lhsOcomments =
              ( _lhsIcomments
              )
          in
            (_lhsOcomments, _lhsOcopy, _lhsOisMultiline, _lhsOisNil, _lhsOpretty)
        )
  )

-- FieldSep ----------------------------------------------------
-- cata
sem_FieldSep
  :: FieldSep
  -> T_FieldSep
sem_FieldSep (CommaSep) =
  (sem_FieldSep_CommaSep)
sem_FieldSep (SemicolonSep) =
  (sem_FieldSep_SemicolonSep)
sem_FieldSep (NoSep) =
  (sem_FieldSep_NoSep)

-- semantic domain
type T_FieldSep =
  Int
  -> PrettyPrintConfig
  -> (FieldSep, Bool, Bool, Doc)
data Inh_FieldSep = Inh_FieldSep {indent_Inh_FieldSep :: Int, ppconf_Inh_FieldSep :: PrettyPrintConfig}
data Syn_FieldSep = Syn_FieldSep {copy_Syn_FieldSep :: FieldSep, isMultiline_Syn_FieldSep :: Bool, isSemiColon_Syn_FieldSep :: Bool, pretty_Syn_FieldSep :: Doc}
wrap_FieldSep
  :: T_FieldSep
  -> Inh_FieldSep
  -> Syn_FieldSep
wrap_FieldSep sem (Inh_FieldSep _lhsIindent _lhsIppconf) =
  ( let
      (_lhsOcopy, _lhsOisMultiline, _lhsOisSemiColon, _lhsOpretty) = sem _lhsIindent _lhsIppconf
    in
      (Syn_FieldSep _lhsOcopy _lhsOisMultiline _lhsOisSemiColon _lhsOpretty)
  )
sem_FieldSep_CommaSep :: T_FieldSep
sem_FieldSep_CommaSep =
  ( \_lhsIindent
     _lhsIppconf ->
        ( let
            _lhsOpretty :: Doc
            _lhsOisMultiline :: Bool
            _lhsOisSemiColon :: Bool
            _lhsOcopy :: FieldSep
            _lhsOpretty =
              ( (if spaceBeforeComma _lhsIppconf then zchr ' ' else empty) <> zchr ','
              )
            _lhsOisMultiline =
              ( False
              )
            _lhsOisSemiColon =
              ( False
              )
            _copy =
              ( CommaSep
              )
            _lhsOcopy =
              ( _copy
              )
          in
            (_lhsOcopy, _lhsOisMultiline, _lhsOisSemiColon, _lhsOpretty)
        )
  )
sem_FieldSep_SemicolonSep :: T_FieldSep
sem_FieldSep_SemicolonSep =
  ( \_lhsIindent
     _lhsIppconf ->
        ( let
            _lhsOpretty :: Doc
            _lhsOisSemiColon :: Bool
            _lhsOisMultiline :: Bool
            _lhsOcopy :: FieldSep
            _lhsOpretty =
              ( (if spaceBeforeComma _lhsIppconf then zchr ' ' else empty) <> zchr ';'
              )
            _lhsOisSemiColon =
              ( True
              )
            _lhsOisMultiline =
              ( True
              )
            _copy =
              ( SemicolonSep
              )
            _lhsOcopy =
              ( _copy
              )
          in
            (_lhsOcopy, _lhsOisMultiline, _lhsOisSemiColon, _lhsOpretty)
        )
  )
sem_FieldSep_NoSep :: T_FieldSep
sem_FieldSep_NoSep =
  ( \_lhsIindent
     _lhsIppconf ->
        ( let
            _lhsOpretty :: Doc
            _lhsOisMultiline :: Bool
            _lhsOisSemiColon :: Bool
            _lhsOcopy :: FieldSep
            _lhsOpretty =
              ( empty
              )
            _lhsOisMultiline =
              ( False
              )
            _lhsOisSemiColon =
              ( False
              )
            _copy =
              ( NoSep
              )
            _lhsOcopy =
              ( _copy
              )
          in
            (_lhsOcopy, _lhsOisMultiline, _lhsOisSemiColon, _lhsOpretty)
        )
  )

-- FuncName ----------------------------------------------------
-- cata
sem_FuncName
  :: FuncName
  -> T_FuncName
sem_FuncName (FuncName _names _meta) =
  (sem_FuncName_FuncName _names _meta)

-- semantic domain
type T_FuncName =
  ([MToken])
  -> Int
  -> PrettyPrintConfig
  -> (([MToken]), FuncName, Bool, Region, Doc)
data Inh_FuncName = Inh_FuncName {comments_Inh_FuncName :: ([MToken]), indent_Inh_FuncName :: Int, ppconf_Inh_FuncName :: PrettyPrintConfig}
data Syn_FuncName = Syn_FuncName {comments_Syn_FuncName :: ([MToken]), copy_Syn_FuncName :: FuncName, isMultiline_Syn_FuncName :: Bool, pos_Syn_FuncName :: Region, pretty_Syn_FuncName :: Doc}
wrap_FuncName
  :: T_FuncName
  -> Inh_FuncName
  -> Syn_FuncName
wrap_FuncName sem (Inh_FuncName _lhsIcomments _lhsIindent _lhsIppconf) =
  ( let
      (_lhsOcomments, _lhsOcopy, _lhsOisMultiline, _lhsOpos, _lhsOpretty) = sem _lhsIcomments _lhsIindent _lhsIppconf
    in
      (Syn_FuncName _lhsOcomments _lhsOcopy _lhsOisMultiline _lhsOpos _lhsOpretty)
  )
sem_FuncName_FuncName
  :: ([MToken])
  -> (Maybe MToken)
  -> T_FuncName
sem_FuncName_FuncName names_ meta_ =
  ( \_lhsIcomments
     _lhsIindent
     _lhsIppconf ->
        ( let
            _lhsOpretty :: Doc
            _lhsOisMultiline :: Bool
            _lhsOpos :: Region
            _lhsOcopy :: FuncName
            _lhsOcomments :: ([MToken])
            _lhsOpretty =
              ( printList tok "." names_ <> metaDoc meta_
              )
            _lhsOisMultiline =
              ( False
              )
            _lhsOpos =
              ( case meta_ of
                  Nothing -> _namesPos
                  Just name -> rgOr _namesPos (mpos name)
              )
            _namesPos =
              ( foldl1 rgOr $ map mpos names_
              )
            _copy =
              ( FuncName names_ meta_
              )
            _lhsOcopy =
              ( _copy
              )
            _lhsOcomments =
              ( _lhsIcomments
              )
          in
            (_lhsOcomments, _lhsOcopy, _lhsOisMultiline, _lhsOpos, _lhsOpretty)
        )
  )

-- MElse -------------------------------------------------------
-- cata
sem_MElse
  :: MElse
  -> T_MElse
sem_MElse (MElse _pos _body) =
  (sem_MElse_MElse _pos (sem_Block _body))

-- semantic domain
type T_MElse =
  ([MToken])
  -> Bool
  -> Int
  -> PrettyPrintConfig
  -> Region
  -> (([MToken]), MElse, Bool, Bool, Region, Doc)
data Inh_MElse = Inh_MElse {comments_Inh_MElse :: ([MToken]), forceMultiline_Inh_MElse :: Bool, indent_Inh_MElse :: Int, ppconf_Inh_MElse :: PrettyPrintConfig, statRegion_Inh_MElse :: Region}
data Syn_MElse = Syn_MElse {comments_Syn_MElse :: ([MToken]), copy_Syn_MElse :: MElse, elsesExist_Syn_MElse :: Bool, isMultiline_Syn_MElse :: Bool, pos_Syn_MElse :: Region, pretty_Syn_MElse :: Doc}
wrap_MElse
  :: T_MElse
  -> Inh_MElse
  -> Syn_MElse
wrap_MElse sem (Inh_MElse _lhsIcomments _lhsIforceMultiline _lhsIindent _lhsIppconf _lhsIstatRegion) =
  ( let
      (_lhsOcomments, _lhsOcopy, _lhsOelsesExist, _lhsOisMultiline, _lhsOpos, _lhsOpretty) = sem _lhsIcomments _lhsIforceMultiline _lhsIindent _lhsIppconf _lhsIstatRegion
    in
      (Syn_MElse _lhsOcomments _lhsOcopy _lhsOelsesExist _lhsOisMultiline _lhsOpos _lhsOpretty)
  )
sem_MElse_MElse
  :: Region
  -> T_Block
  -> T_MElse
sem_MElse_MElse pos_ body_ =
  ( \_lhsIcomments
     _lhsIforceMultiline
     _lhsIindent
     _lhsIppconf
     _lhsIstatRegion ->
        ( let
            _lhsOpretty :: Doc
            _lhsOisMultiline :: Bool
            _bodyOindent :: Int
            _lhsOpos :: Region
            _bodyOcomments :: ([MToken])
            _lhsOelsesExist :: Bool
            _lhsOcopy :: MElse
            _lhsOcomments :: ([MToken])
            _bodyOforceMultiline :: Bool
            _bodyOppconf :: PrettyPrintConfig
            _bodyOstatRegion :: Region
            _bodyIcomments :: ([MToken])
            _bodyIcopy :: Block
            _bodyIisMultiline :: Bool
            _bodyIpretty :: Doc
            _bodyIstatementCount :: Int
            _lhsOpretty =
              ( indent _lhsIppconf _lhsIindent (zeroWidthText "else")
                  <-> _prettyCommentsAfter
                  $+$ _bodyIpretty
              )
            _lhsOisMultiline =
              ( _bodyIisMultiline
              )
            _bodyOindent =
              ( _lhsIindent + 1
              )
            _prettyCommentsAfter =
              ( renderSLComments _lhsIppconf _lhsIindent (fst _commentsAfter)
              )
            _commentsAfter =
              ( span (\(MToken pos _) -> pos `beforeOrOnLine` pos_) _lhsIcomments
              )
            _lhsOpos =
              ( pos_
              )
            _bodyOcomments =
              ( snd _commentsAfter
              )
            _lhsOelsesExist =
              ( False
              )
            _copy =
              ( MElse pos_ _bodyIcopy
              )
            _lhsOcopy =
              ( _copy
              )
            _lhsOcomments =
              ( _bodyIcomments
              )
            _bodyOforceMultiline =
              ( _lhsIforceMultiline
              )
            _bodyOppconf =
              ( _lhsIppconf
              )
            _bodyOstatRegion =
              ( _lhsIstatRegion
              )
            (_bodyIcomments, _bodyIcopy, _bodyIisMultiline, _bodyIpretty, _bodyIstatementCount) =
              body_ _bodyOcomments _bodyOforceMultiline _bodyOindent _bodyOppconf _bodyOstatRegion
          in
            (_lhsOcomments, _lhsOcopy, _lhsOelsesExist, _lhsOisMultiline, _lhsOpos, _lhsOpretty)
        )
  )

-- MElseIf -----------------------------------------------------
-- cata
sem_MElseIf
  :: MElseIf
  -> T_MElseIf
sem_MElseIf (MElseIf _pos _elif) =
  (sem_MElseIf_MElseIf _pos (sem_ElseIf _elif))

-- semantic domain
type T_MElseIf =
  ([MToken])
  -> Bool
  -> Int
  -> PrettyPrintConfig
  -> (([MToken]), MElseIf, Bool, Region, Doc)
data Inh_MElseIf = Inh_MElseIf {comments_Inh_MElseIf :: ([MToken]), forceMultiline_Inh_MElseIf :: Bool, indent_Inh_MElseIf :: Int, ppconf_Inh_MElseIf :: PrettyPrintConfig}
data Syn_MElseIf = Syn_MElseIf {comments_Syn_MElseIf :: ([MToken]), copy_Syn_MElseIf :: MElseIf, isMultiline_Syn_MElseIf :: Bool, pos_Syn_MElseIf :: Region, pretty_Syn_MElseIf :: Doc}
wrap_MElseIf
  :: T_MElseIf
  -> Inh_MElseIf
  -> Syn_MElseIf
wrap_MElseIf sem (Inh_MElseIf _lhsIcomments _lhsIforceMultiline _lhsIindent _lhsIppconf) =
  ( let
      (_lhsOcomments, _lhsOcopy, _lhsOisMultiline, _lhsOpos, _lhsOpretty) = sem _lhsIcomments _lhsIforceMultiline _lhsIindent _lhsIppconf
    in
      (Syn_MElseIf _lhsOcomments _lhsOcopy _lhsOisMultiline _lhsOpos _lhsOpretty)
  )
sem_MElseIf_MElseIf
  :: Region
  -> T_ElseIf
  -> T_MElseIf
sem_MElseIf_MElseIf pos_ elif_ =
  ( \_lhsIcomments
     _lhsIforceMultiline
     _lhsIindent
     _lhsIppconf ->
        ( let
            _lhsOpos :: Region
            _lhsOisMultiline :: Bool
            _lhsOcopy :: MElseIf
            _lhsOcomments :: ([MToken])
            _lhsOpretty :: Doc
            _elifOcomments :: ([MToken])
            _elifOforceMultiline :: Bool
            _elifOindent :: Int
            _elifOppconf :: PrettyPrintConfig
            _elifIcomments :: ([MToken])
            _elifIcopy :: ElseIf
            _elifIisMultiline :: Bool
            _elifIpretty :: Doc
            _lhsOpos =
              ( pos_
              )
            _lhsOisMultiline =
              ( _elifIisMultiline
              )
            _copy =
              ( MElseIf pos_ _elifIcopy
              )
            _lhsOcopy =
              ( _copy
              )
            _lhsOcomments =
              ( _elifIcomments
              )
            _lhsOpretty =
              ( _elifIpretty
              )
            _elifOcomments =
              ( _lhsIcomments
              )
            _elifOforceMultiline =
              ( _lhsIforceMultiline
              )
            _elifOindent =
              ( _lhsIindent
              )
            _elifOppconf =
              ( _lhsIppconf
              )
            (_elifIcomments, _elifIcopy, _elifIisMultiline, _elifIpretty) =
              elif_ _elifOcomments _elifOforceMultiline _elifOindent _elifOppconf
          in
            (_lhsOcomments, _lhsOcopy, _lhsOisMultiline, _lhsOpos, _lhsOpretty)
        )
  )

-- MExpr -------------------------------------------------------
-- cata
sem_MExpr
  :: MExpr
  -> T_MExpr
sem_MExpr (MExpr _pos _expr) =
  (sem_MExpr_MExpr _pos (sem_Expr _expr))

-- semantic domain
type T_MExpr =
  ([MToken])
  -> Bool
  -> Int
  -> Bool
  -> OperatorLevel
  -> PrettyPrintConfig
  -> (([MToken]), MExpr, Bool, Bool, Bool, Bool, Region, OperatorLevel, Doc)
data Inh_MExpr = Inh_MExpr {comments_Inh_MExpr :: ([MToken]), forceMultiline_Inh_MExpr :: Bool, indent_Inh_MExpr :: Int, parentOperatorAssociative_Inh_MExpr :: Bool, parentOperatorPrecedence_Inh_MExpr :: OperatorLevel, ppconf_Inh_MExpr :: PrettyPrintConfig}
data Syn_MExpr = Syn_MExpr {comments_Syn_MExpr :: ([MToken]), copy_Syn_MExpr :: MExpr, endsWithPrefixExpression_Syn_MExpr :: Bool, isAssociative_Syn_MExpr :: Bool, isLiteral_Syn_MExpr :: Bool, isMultiline_Syn_MExpr :: Bool, pos_Syn_MExpr :: Region, precedence_Syn_MExpr :: OperatorLevel, pretty_Syn_MExpr :: Doc}
wrap_MExpr
  :: T_MExpr
  -> Inh_MExpr
  -> Syn_MExpr
wrap_MExpr sem (Inh_MExpr _lhsIcomments _lhsIforceMultiline _lhsIindent _lhsIparentOperatorAssociative _lhsIparentOperatorPrecedence _lhsIppconf) =
  ( let
      (_lhsOcomments, _lhsOcopy, _lhsOendsWithPrefixExpression, _lhsOisAssociative, _lhsOisLiteral, _lhsOisMultiline, _lhsOpos, _lhsOprecedence, _lhsOpretty) = sem _lhsIcomments _lhsIforceMultiline _lhsIindent _lhsIparentOperatorAssociative _lhsIparentOperatorPrecedence _lhsIppconf
    in
      (Syn_MExpr _lhsOcomments _lhsOcopy _lhsOendsWithPrefixExpression _lhsOisAssociative _lhsOisLiteral _lhsOisMultiline _lhsOpos _lhsOprecedence _lhsOpretty)
  )
sem_MExpr_MExpr
  :: Region
  -> T_Expr
  -> T_MExpr
sem_MExpr_MExpr pos_ expr_ =
  ( \_lhsIcomments
     _lhsIforceMultiline
     _lhsIindent
     _lhsIparentOperatorAssociative
     _lhsIparentOperatorPrecedence
     _lhsIppconf ->
        ( let
            _lhsOpos :: Region
            _lhsOendsWithPrefixExpression :: Bool
            _lhsOisMultiline :: Bool
            _exprOstatRegion :: Region
            _lhsOisAssociative :: Bool
            _lhsOisLiteral :: Bool
            _lhsOprecedence :: OperatorLevel
            _lhsOcopy :: MExpr
            _lhsOcomments :: ([MToken])
            _lhsOpretty :: Doc
            _exprOcomments :: ([MToken])
            _exprOforceMultiline :: Bool
            _exprOindent :: Int
            _exprOparentOperatorAssociative :: Bool
            _exprOparentOperatorPrecedence :: OperatorLevel
            _exprOppconf :: PrettyPrintConfig
            _exprIcomments :: ([MToken])
            _exprIcopy :: Expr
            _exprIendsWithPrefixExpression :: Bool
            _exprIisAssociative :: Bool
            _exprIisLiteral :: Bool
            _exprIisMultiline :: Bool
            _exprIprecedence :: OperatorLevel
            _exprIpretty :: Doc
            _lhsOpos =
              ( pos_
              )
            _lhsOendsWithPrefixExpression =
              ( _exprIendsWithPrefixExpression
              )
            _lhsOisMultiline =
              ( _exprIisMultiline
              )
            _exprOstatRegion =
              ( pos_
              )
            _lhsOisAssociative =
              ( _exprIisAssociative
              )
            _lhsOisLiteral =
              ( _exprIisLiteral
              )
            _lhsOprecedence =
              ( _exprIprecedence
              )
            _copy =
              ( MExpr pos_ _exprIcopy
              )
            _lhsOcopy =
              ( _copy
              )
            _lhsOcomments =
              ( _exprIcomments
              )
            _lhsOpretty =
              ( _exprIpretty
              )
            _exprOcomments =
              ( _lhsIcomments
              )
            _exprOforceMultiline =
              ( _lhsIforceMultiline
              )
            _exprOindent =
              ( _lhsIindent
              )
            _exprOparentOperatorAssociative =
              ( _lhsIparentOperatorAssociative
              )
            _exprOparentOperatorPrecedence =
              ( _lhsIparentOperatorPrecedence
              )
            _exprOppconf =
              ( _lhsIppconf
              )
            (_exprIcomments, _exprIcopy, _exprIendsWithPrefixExpression, _exprIisAssociative, _exprIisLiteral, _exprIisMultiline, _exprIprecedence, _exprIpretty) =
              expr_ _exprOcomments _exprOforceMultiline _exprOindent _exprOparentOperatorAssociative _exprOparentOperatorPrecedence _exprOppconf _exprOstatRegion
          in
            (_lhsOcomments, _lhsOcopy, _lhsOendsWithPrefixExpression, _lhsOisAssociative, _lhsOisLiteral, _lhsOisMultiline, _lhsOpos, _lhsOprecedence, _lhsOpretty)
        )
  )

-- MExprList ---------------------------------------------------
-- cata
sem_MExprList
  :: MExprList
  -> T_MExprList
sem_MExprList list =
  (Prelude.foldr sem_MExprList_Cons sem_MExprList_Nil (Prelude.map sem_MExpr list))

-- semantic domain
type T_MExprList =
  ([MToken])
  -> Bool
  -> Int
  -> PrettyPrintConfig
  -> Bool
  -> (([MToken]), MExprList, Bool, Bool, Bool, Region, OperatorLevel, Doc)
data Inh_MExprList = Inh_MExprList {comments_Inh_MExprList :: ([MToken]), forceMultiline_Inh_MExprList :: Bool, indent_Inh_MExprList :: Int, ppconf_Inh_MExprList :: PrettyPrintConfig, someElementsInListAreMultiline_Inh_MExprList :: Bool}
data Syn_MExprList = Syn_MExprList {comments_Syn_MExprList :: ([MToken]), copy_Syn_MExprList :: MExprList, isAssociative_Syn_MExprList :: Bool, isLast_Syn_MExprList :: Bool, isMultiline_Syn_MExprList :: Bool, pos_Syn_MExprList :: Region, precedence_Syn_MExprList :: OperatorLevel, pretty_Syn_MExprList :: Doc}
wrap_MExprList
  :: T_MExprList
  -> Inh_MExprList
  -> Syn_MExprList
wrap_MExprList sem (Inh_MExprList _lhsIcomments _lhsIforceMultiline _lhsIindent _lhsIppconf _lhsIsomeElementsInListAreMultiline) =
  ( let
      (_lhsOcomments, _lhsOcopy, _lhsOisAssociative, _lhsOisLast, _lhsOisMultiline, _lhsOpos, _lhsOprecedence, _lhsOpretty) = sem _lhsIcomments _lhsIforceMultiline _lhsIindent _lhsIppconf _lhsIsomeElementsInListAreMultiline
    in
      (Syn_MExprList _lhsOcomments _lhsOcopy _lhsOisAssociative _lhsOisLast _lhsOisMultiline _lhsOpos _lhsOprecedence _lhsOpretty)
  )
sem_MExprList_Cons
  :: T_MExpr
  -> T_MExprList
  -> T_MExprList
sem_MExprList_Cons hd_ tl_ =
  ( \_lhsIcomments
     _lhsIforceMultiline
     _lhsIindent
     _lhsIppconf
     _lhsIsomeElementsInListAreMultiline ->
        ( let
            _lhsOpretty :: Doc
            _hdOcomments :: ([MToken])
            _tlOcomments :: ([MToken])
            _lhsOcomments :: ([MToken])
            _lhsOpos :: Region
            _lhsOisLast :: Bool
            _hdOparentOperatorPrecedence :: OperatorLevel
            _hdOparentOperatorAssociative :: Bool
            _tlOsomeElementsInListAreMultiline :: Bool
            _lhsOisAssociative :: Bool
            _lhsOprecedence :: OperatorLevel
            _lhsOcopy :: MExprList
            _lhsOisMultiline :: Bool
            _hdOforceMultiline :: Bool
            _hdOindent :: Int
            _hdOppconf :: PrettyPrintConfig
            _tlOforceMultiline :: Bool
            _tlOindent :: Int
            _tlOppconf :: PrettyPrintConfig
            _hdIcomments :: ([MToken])
            _hdIcopy :: MExpr
            _hdIendsWithPrefixExpression :: Bool
            _hdIisAssociative :: Bool
            _hdIisLiteral :: Bool
            _hdIisMultiline :: Bool
            _hdIpos :: Region
            _hdIprecedence :: OperatorLevel
            _hdIpretty :: Doc
            _tlIcomments :: ([MToken])
            _tlIcopy :: MExprList
            _tlIisAssociative :: Bool
            _tlIisLast :: Bool
            _tlIisMultiline :: Bool
            _tlIpos :: Region
            _tlIprecedence :: OperatorLevel
            _tlIpretty :: Doc
            _lhsOpretty =
              ( if _isMultiline then _prettyMultiLine else _prettySingleLine
              )
            _prettySingleLine =
              ( _hdIpretty
                  <> _comma
                  <> _tlIpretty
              )
            _prettyMultiLine =
              ( renderMLComments _lhsIppconf _lhsIindent (fst _commentsBeforeLine)
                  $+$ indent _lhsIppconf _lhsIindent _hdIpretty
                    <> _comma
                      <-> renderSLComments _lhsIppconf _lhsIindent (fst _commentsAfter)
                  $+$ _tlIpretty
              )
            _comma =
              ( if _tlIisLast
                  then empty
                  else
                    (if spaceBeforeComma _lhsIppconf then zchr ' ' else empty)
                      <> zchr ','
                      <> (if not _isMultiline && spaceAfterComma _lhsIppconf then zchr ' ' else empty)
              )
            _commentsBeforeLine =
              ( span (\(MToken pos' _) -> pos' `before` _hdIpos) _lhsIcomments
              )
            _hdOcomments =
              ( snd _commentsBeforeLine
              )
            _commentsAfter =
              ( span (\(MToken pos' _) -> pos' `before` _tlIpos) _hdIcomments
              )
            _tlOcomments =
              ( snd _commentsAfter
              )
            _lhsOcomments =
              ( _tlIcomments
              )
            _lhsOpos =
              ( _hdIpos
              )
            _lhsOisLast =
              ( False
              )
            _hdOparentOperatorPrecedence =
              ( TopLevelExpression
              )
            _hdOparentOperatorAssociative =
              ( True
              )
            _isMultiline =
              ( _lhsIforceMultiline
                  || not (null $ fst _commentsBeforeLine)
                  || not (null $ fst _commentsAfter)
                  || _lhsIsomeElementsInListAreMultiline
                  || _hdIisMultiline
                  || _tlIisMultiline
              )
            _tlOsomeElementsInListAreMultiline =
              ( _lhsIsomeElementsInListAreMultiline
                  || _hdIisMultiline
                  || not (null $ fst _commentsBeforeLine)
                  || not (null $ fst _commentsAfter)
              )
            _lhsOisAssociative =
              ( _hdIisAssociative && _tlIisAssociative
              )
            _lhsOprecedence =
              ( (min _hdIprecedence _tlIprecedence)
              )
            _copy =
              ( (:) _hdIcopy _tlIcopy
              )
            _lhsOcopy =
              ( _copy
              )
            _lhsOisMultiline =
              ( _isMultiline
              )
            _hdOforceMultiline =
              ( _lhsIforceMultiline
              )
            _hdOindent =
              ( _lhsIindent
              )
            _hdOppconf =
              ( _lhsIppconf
              )
            _tlOforceMultiline =
              ( _lhsIforceMultiline
              )
            _tlOindent =
              ( _lhsIindent
              )
            _tlOppconf =
              ( _lhsIppconf
              )
            (_hdIcomments, _hdIcopy, _hdIendsWithPrefixExpression, _hdIisAssociative, _hdIisLiteral, _hdIisMultiline, _hdIpos, _hdIprecedence, _hdIpretty) =
              hd_ _hdOcomments _hdOforceMultiline _hdOindent _hdOparentOperatorAssociative _hdOparentOperatorPrecedence _hdOppconf
            (_tlIcomments, _tlIcopy, _tlIisAssociative, _tlIisLast, _tlIisMultiline, _tlIpos, _tlIprecedence, _tlIpretty) =
              tl_ _tlOcomments _tlOforceMultiline _tlOindent _tlOppconf _tlOsomeElementsInListAreMultiline
          in
            (_lhsOcomments, _lhsOcopy, _lhsOisAssociative, _lhsOisLast, _lhsOisMultiline, _lhsOpos, _lhsOprecedence, _lhsOpretty)
        )
  )
sem_MExprList_Nil :: T_MExprList
sem_MExprList_Nil =
  ( \_lhsIcomments
     _lhsIforceMultiline
     _lhsIindent
     _lhsIppconf
     _lhsIsomeElementsInListAreMultiline ->
        ( let
            _lhsOpretty :: Doc
            _lhsOpos :: Region
            _lhsOisMultiline :: Bool
            _lhsOisLast :: Bool
            _lhsOisAssociative :: Bool
            _lhsOprecedence :: OperatorLevel
            _lhsOcopy :: MExprList
            _lhsOcomments :: ([MToken])
            _lhsOpretty =
              ( empty
              )
            _lhsOpos =
              ( emptyRg
              )
            _lhsOisMultiline =
              ( False
              )
            _lhsOisLast =
              ( True
              )
            _lhsOisAssociative =
              ( False
              )
            _lhsOprecedence =
              ( OperatorLevel8
              )
            _copy =
              ( []
              )
            _lhsOcopy =
              ( _copy
              )
            _lhsOcomments =
              ( _lhsIcomments
              )
          in
            (_lhsOcomments, _lhsOcopy, _lhsOisAssociative, _lhsOisLast, _lhsOisMultiline, _lhsOpos, _lhsOprecedence, _lhsOpretty)
        )
  )

-- MStat -------------------------------------------------------
-- cata
sem_MStat
  :: MStat
  -> T_MStat
sem_MStat (MStat _pos _stat) =
  (sem_MStat_MStat _pos (sem_Stat _stat))

-- semantic domain
type T_MStat =
  ([MToken])
  -> Bool
  -> Int
  -> Bool
  -> PrettyPrintConfig
  -> Bool
  -> (([MToken]), MStat, Bool, Bool, Region, Doc, Bool, Int)
data Inh_MStat = Inh_MStat {comments_Inh_MStat :: ([MToken]), forceMultiline_Inh_MStat :: Bool, indent_Inh_MStat :: Int, isLastStatement_Inh_MStat :: Bool, ppconf_Inh_MStat :: PrettyPrintConfig, wouldBeAmbiguousWithoutSemicolon_Inh_MStat :: Bool}
data Syn_MStat = Syn_MStat {comments_Syn_MStat :: ([MToken]), copy_Syn_MStat :: MStat, endsWithPrefixExpression_Syn_MStat :: Bool, isMultiline_Syn_MStat :: Bool, pos_Syn_MStat :: Region, pretty_Syn_MStat :: Doc, startsWithExprPrefixExpression_Syn_MStat :: Bool, statementCount_Syn_MStat :: Int}
wrap_MStat
  :: T_MStat
  -> Inh_MStat
  -> Syn_MStat
wrap_MStat sem (Inh_MStat _lhsIcomments _lhsIforceMultiline _lhsIindent _lhsIisLastStatement _lhsIppconf _lhsIwouldBeAmbiguousWithoutSemicolon) =
  ( let
      (_lhsOcomments, _lhsOcopy, _lhsOendsWithPrefixExpression, _lhsOisMultiline, _lhsOpos, _lhsOpretty, _lhsOstartsWithExprPrefixExpression, _lhsOstatementCount) = sem _lhsIcomments _lhsIforceMultiline _lhsIindent _lhsIisLastStatement _lhsIppconf _lhsIwouldBeAmbiguousWithoutSemicolon
    in
      (Syn_MStat _lhsOcomments _lhsOcopy _lhsOendsWithPrefixExpression _lhsOisMultiline _lhsOpos _lhsOpretty _lhsOstartsWithExprPrefixExpression _lhsOstatementCount)
  )
sem_MStat_MStat
  :: Region
  -> T_Stat
  -> T_MStat
sem_MStat_MStat pos_ stat_ =
  ( \_lhsIcomments
     _lhsIforceMultiline
     _lhsIindent
     _lhsIisLastStatement
     _lhsIppconf
     _lhsIwouldBeAmbiguousWithoutSemicolon ->
        ( let
            _lhsOpos :: Region
            _lhsOstartsWithExprPrefixExpression :: Bool
            _lhsOendsWithPrefixExpression :: Bool
            _lhsOisMultiline :: Bool
            _statOstatRegion :: Region
            _statOwouldBeAmbiguousWithoutSemicolon :: Bool
            _lhsOstatementCount :: Int
            _lhsOcopy :: MStat
            _lhsOcomments :: ([MToken])
            _lhsOpretty :: Doc
            _statOcomments :: ([MToken])
            _statOforceMultiline :: Bool
            _statOindent :: Int
            _statOisLastStatement :: Bool
            _statOppconf :: PrettyPrintConfig
            _statIcomments :: ([MToken])
            _statIcopy :: Stat
            _statIendsWithPrefixExpression :: Bool
            _statIisMultiline :: Bool
            _statIpretty :: Doc
            _statIstartsWithExprPrefixExpression :: Bool
            _lhsOpos =
              ( pos_
              )
            _lhsOstartsWithExprPrefixExpression =
              ( _statIstartsWithExprPrefixExpression
              )
            _lhsOendsWithPrefixExpression =
              ( _statIendsWithPrefixExpression
              )
            _lhsOisMultiline =
              ( _statIisMultiline
              )
            _statOstatRegion =
              ( pos_
              )
            _statOwouldBeAmbiguousWithoutSemicolon =
              ( _lhsIwouldBeAmbiguousWithoutSemicolon
              )
            _lhsOstatementCount =
              ( 1
              )
            _copy =
              ( MStat pos_ _statIcopy
              )
            _lhsOcopy =
              ( _copy
              )
            _lhsOcomments =
              ( _statIcomments
              )
            _lhsOpretty =
              ( _statIpretty
              )
            _statOcomments =
              ( _lhsIcomments
              )
            _statOforceMultiline =
              ( _lhsIforceMultiline
              )
            _statOindent =
              ( _lhsIindent
              )
            _statOisLastStatement =
              ( _lhsIisLastStatement
              )
            _statOppconf =
              ( _lhsIppconf
              )
            (_statIcomments, _statIcopy, _statIendsWithPrefixExpression, _statIisMultiline, _statIpretty, _statIstartsWithExprPrefixExpression) =
              stat_ _statOcomments _statOforceMultiline _statOindent _statOisLastStatement _statOppconf _statOstatRegion _statOwouldBeAmbiguousWithoutSemicolon
          in
            (_lhsOcomments, _lhsOcopy, _lhsOendsWithPrefixExpression, _lhsOisMultiline, _lhsOpos, _lhsOpretty, _lhsOstartsWithExprPrefixExpression, _lhsOstatementCount)
        )
  )

-- MStatList ---------------------------------------------------
-- cata
sem_MStatList
  :: MStatList
  -> T_MStatList
sem_MStatList list =
  (Prelude.foldr sem_MStatList_Cons sem_MStatList_Nil (Prelude.map sem_MStat list))

-- semantic domain
type T_MStatList =
  ([MToken])
  -> Bool
  -> Int
  -> PrettyPrintConfig
  -> Region
  -> (([MToken]), MStatList, Bool, Bool, Doc, Bool, Int)
data Inh_MStatList = Inh_MStatList {comments_Inh_MStatList :: ([MToken]), forceMultiline_Inh_MStatList :: Bool, indent_Inh_MStatList :: Int, ppconf_Inh_MStatList :: PrettyPrintConfig, statRegion_Inh_MStatList :: Region}
data Syn_MStatList = Syn_MStatList {comments_Syn_MStatList :: ([MToken]), copy_Syn_MStatList :: MStatList, isLast_Syn_MStatList :: Bool, isMultiline_Syn_MStatList :: Bool, pretty_Syn_MStatList :: Doc, startsWithExprPrefixExpression_Syn_MStatList :: Bool, statementCount_Syn_MStatList :: Int}
wrap_MStatList
  :: T_MStatList
  -> Inh_MStatList
  -> Syn_MStatList
wrap_MStatList sem (Inh_MStatList _lhsIcomments _lhsIforceMultiline _lhsIindent _lhsIppconf _lhsIstatRegion) =
  ( let
      (_lhsOcomments, _lhsOcopy, _lhsOisLast, _lhsOisMultiline, _lhsOpretty, _lhsOstartsWithExprPrefixExpression, _lhsOstatementCount) = sem _lhsIcomments _lhsIforceMultiline _lhsIindent _lhsIppconf _lhsIstatRegion
    in
      (Syn_MStatList _lhsOcomments _lhsOcopy _lhsOisLast _lhsOisMultiline _lhsOpretty _lhsOstartsWithExprPrefixExpression _lhsOstatementCount)
  )
sem_MStatList_Cons
  :: T_MStat
  -> T_MStatList
  -> T_MStatList
sem_MStatList_Cons hd_ tl_ =
  ( \_lhsIcomments
     _lhsIforceMultiline
     _lhsIindent
     _lhsIppconf
     _lhsIstatRegion ->
        ( let
            _lhsOpretty :: Doc
            _lhsOstartsWithExprPrefixExpression :: Bool
            _lhsOisLast :: Bool
            _hdOcomments :: ([MToken])
            _tlOcomments :: ([MToken])
            _lhsOcomments :: ([MToken])
            _hdOisLastStatement :: Bool
            _hdOwouldBeAmbiguousWithoutSemicolon :: Bool
            _hdOforceMultiline :: Bool
            _lhsOstatementCount :: Int
            _lhsOcopy :: MStatList
            _lhsOisMultiline :: Bool
            _hdOindent :: Int
            _hdOppconf :: PrettyPrintConfig
            _tlOforceMultiline :: Bool
            _tlOindent :: Int
            _tlOppconf :: PrettyPrintConfig
            _tlOstatRegion :: Region
            _hdIcomments :: ([MToken])
            _hdIcopy :: MStat
            _hdIendsWithPrefixExpression :: Bool
            _hdIisMultiline :: Bool
            _hdIpos :: Region
            _hdIpretty :: Doc
            _hdIstartsWithExprPrefixExpression :: Bool
            _hdIstatementCount :: Int
            _tlIcomments :: ([MToken])
            _tlIcopy :: MStatList
            _tlIisLast :: Bool
            _tlIisMultiline :: Bool
            _tlIpretty :: Doc
            _tlIstartsWithExprPrefixExpression :: Bool
            _tlIstatementCount :: Int
            _lhsOpretty =
              ( renderMLComments _lhsIppconf _lhsIindent (fst _commentsBeforeLine)
                  $+$ indent _lhsIppconf _lhsIindent _hdIpretty
                    <-> renderSLComments _lhsIppconf _lhsIindent (fst _commentsAfter)
                    <> _addNewline
                  $+$ _tlIpretty
              )
            _lhsOstartsWithExprPrefixExpression =
              ( _hdIstartsWithExprPrefixExpression
              )
            _lhsOisLast =
              ( False
              )
            _isMultiline =
              ( _hdIisMultiline
                  || _tlIisMultiline
                  || not (null $ fst _commentsBeforeLine)
                  || not (null $ fst _commentsAfter)
              )
            _addNewline =
              ( if not _tlIisLast && _hdIisMultiline then zchr '\n' else empty
              )
            _commentsBeforeLine =
              ( span (\(MToken pos' _) -> pos' `before` _hdIpos) _lhsIcomments
              )
            _hdOcomments =
              ( snd _commentsBeforeLine
              )
            _commentsAfter =
              ( span (\(MToken pos' _) -> pos' `beforeOrOnLine` _hdIpos) _hdIcomments
              )
            _tlOcomments =
              ( snd _commentsAfter
              )
            _lhsOcomments =
              ( _tlIcomments
              )
            _hdOisLastStatement =
              ( _tlIisLast
              )
            _hdOwouldBeAmbiguousWithoutSemicolon =
              ( _hdIendsWithPrefixExpression && _tlIstartsWithExprPrefixExpression
              )
            _hdOforceMultiline =
              ( commentsForceMultiline $ fst _commentsBeforeLine
              )
            _lhsOstatementCount =
              ( _hdIstatementCount + _tlIstatementCount
              )
            _copy =
              ( (:) _hdIcopy _tlIcopy
              )
            _lhsOcopy =
              ( _copy
              )
            _lhsOisMultiline =
              ( _isMultiline
              )
            _hdOindent =
              ( _lhsIindent
              )
            _hdOppconf =
              ( _lhsIppconf
              )
            _tlOforceMultiline =
              ( _lhsIforceMultiline
              )
            _tlOindent =
              ( _lhsIindent
              )
            _tlOppconf =
              ( _lhsIppconf
              )
            _tlOstatRegion =
              ( _lhsIstatRegion
              )
            (_hdIcomments, _hdIcopy, _hdIendsWithPrefixExpression, _hdIisMultiline, _hdIpos, _hdIpretty, _hdIstartsWithExprPrefixExpression, _hdIstatementCount) =
              hd_ _hdOcomments _hdOforceMultiline _hdOindent _hdOisLastStatement _hdOppconf _hdOwouldBeAmbiguousWithoutSemicolon
            (_tlIcomments, _tlIcopy, _tlIisLast, _tlIisMultiline, _tlIpretty, _tlIstartsWithExprPrefixExpression, _tlIstatementCount) =
              tl_ _tlOcomments _tlOforceMultiline _tlOindent _tlOppconf _tlOstatRegion
          in
            (_lhsOcomments, _lhsOcopy, _lhsOisLast, _lhsOisMultiline, _lhsOpretty, _lhsOstartsWithExprPrefixExpression, _lhsOstatementCount)
        )
  )
sem_MStatList_Nil :: T_MStatList
sem_MStatList_Nil =
  ( \_lhsIcomments
     _lhsIforceMultiline
     _lhsIindent
     _lhsIppconf
     _lhsIstatRegion ->
        ( let
            _lhsOpretty :: Doc
            _lhsOstatementCount :: Int
            _lhsOstartsWithExprPrefixExpression :: Bool
            _lhsOisMultiline :: Bool
            _lhsOisLast :: Bool
            _lhsOcopy :: MStatList
            _lhsOcomments :: ([MToken])
            _lhsOpretty =
              ( empty
              )
            _lhsOstatementCount =
              ( 0
              )
            _lhsOstartsWithExprPrefixExpression =
              ( False
              )
            _lhsOisMultiline =
              ( False
              )
            _lhsOisLast =
              ( True
              )
            _copy =
              ( []
              )
            _lhsOcopy =
              ( _copy
              )
            _lhsOcomments =
              ( _lhsIcomments
              )
          in
            (_lhsOcomments, _lhsOcopy, _lhsOisLast, _lhsOisMultiline, _lhsOpretty, _lhsOstartsWithExprPrefixExpression, _lhsOstatementCount)
        )
  )

-- MaybeMExpr --------------------------------------------------
-- cata
sem_MaybeMExpr
  :: MaybeMExpr
  -> T_MaybeMExpr
sem_MaybeMExpr (Prelude.Just x) =
  (sem_MaybeMExpr_Just (sem_MExpr x))
sem_MaybeMExpr Prelude.Nothing =
  sem_MaybeMExpr_Nothing

-- semantic domain
type T_MaybeMExpr =
  ([MToken])
  -> Bool
  -> Int
  -> PrettyPrintConfig
  -> (([MToken]), MaybeMExpr, Bool, Bool, Bool, Bool, OperatorLevel, Doc)
data Inh_MaybeMExpr = Inh_MaybeMExpr {comments_Inh_MaybeMExpr :: ([MToken]), forceMultiline_Inh_MaybeMExpr :: Bool, indent_Inh_MaybeMExpr :: Int, ppconf_Inh_MaybeMExpr :: PrettyPrintConfig}
data Syn_MaybeMExpr = Syn_MaybeMExpr {comments_Syn_MaybeMExpr :: ([MToken]), copy_Syn_MaybeMExpr :: MaybeMExpr, endsWithPrefixExpression_Syn_MaybeMExpr :: Bool, isAssociative_Syn_MaybeMExpr :: Bool, isDefined_Syn_MaybeMExpr :: Bool, isMultiline_Syn_MaybeMExpr :: Bool, precedence_Syn_MaybeMExpr :: OperatorLevel, pretty_Syn_MaybeMExpr :: Doc}
wrap_MaybeMExpr
  :: T_MaybeMExpr
  -> Inh_MaybeMExpr
  -> Syn_MaybeMExpr
wrap_MaybeMExpr sem (Inh_MaybeMExpr _lhsIcomments _lhsIforceMultiline _lhsIindent _lhsIppconf) =
  ( let
      (_lhsOcomments, _lhsOcopy, _lhsOendsWithPrefixExpression, _lhsOisAssociative, _lhsOisDefined, _lhsOisMultiline, _lhsOprecedence, _lhsOpretty) = sem _lhsIcomments _lhsIforceMultiline _lhsIindent _lhsIppconf
    in
      (Syn_MaybeMExpr _lhsOcomments _lhsOcopy _lhsOendsWithPrefixExpression _lhsOisAssociative _lhsOisDefined _lhsOisMultiline _lhsOprecedence _lhsOpretty)
  )
sem_MaybeMExpr_Just
  :: T_MExpr
  -> T_MaybeMExpr
sem_MaybeMExpr_Just just_ =
  ( \_lhsIcomments
     _lhsIforceMultiline
     _lhsIindent
     _lhsIppconf ->
        ( let
            _lhsOpretty :: Doc
            _lhsOisDefined :: Bool
            _lhsOendsWithPrefixExpression :: Bool
            _lhsOisMultiline :: Bool
            _justOparentOperatorPrecedence :: OperatorLevel
            _justOparentOperatorAssociative :: Bool
            _lhsOisAssociative :: Bool
            _lhsOprecedence :: OperatorLevel
            _lhsOcopy :: MaybeMExpr
            _lhsOcomments :: ([MToken])
            _justOcomments :: ([MToken])
            _justOforceMultiline :: Bool
            _justOindent :: Int
            _justOppconf :: PrettyPrintConfig
            _justIcomments :: ([MToken])
            _justIcopy :: MExpr
            _justIendsWithPrefixExpression :: Bool
            _justIisAssociative :: Bool
            _justIisLiteral :: Bool
            _justIisMultiline :: Bool
            _justIpos :: Region
            _justIprecedence :: OperatorLevel
            _justIpretty :: Doc
            _lhsOpretty =
              ( _justIpretty
              )
            _lhsOisDefined =
              ( True
              )
            _lhsOendsWithPrefixExpression =
              ( _justIendsWithPrefixExpression
              )
            _lhsOisMultiline =
              ( _justIisMultiline
              )
            _justOparentOperatorPrecedence =
              ( TopLevelExpression
              )
            _justOparentOperatorAssociative =
              ( True
              )
            _lhsOisAssociative =
              ( _justIisAssociative
              )
            _lhsOprecedence =
              ( _justIprecedence
              )
            _copy =
              ( Just _justIcopy
              )
            _lhsOcopy =
              ( _copy
              )
            _lhsOcomments =
              ( _justIcomments
              )
            _justOcomments =
              ( _lhsIcomments
              )
            _justOforceMultiline =
              ( _lhsIforceMultiline
              )
            _justOindent =
              ( _lhsIindent
              )
            _justOppconf =
              ( _lhsIppconf
              )
            (_justIcomments, _justIcopy, _justIendsWithPrefixExpression, _justIisAssociative, _justIisLiteral, _justIisMultiline, _justIpos, _justIprecedence, _justIpretty) =
              just_ _justOcomments _justOforceMultiline _justOindent _justOparentOperatorAssociative _justOparentOperatorPrecedence _justOppconf
          in
            (_lhsOcomments, _lhsOcopy, _lhsOendsWithPrefixExpression, _lhsOisAssociative, _lhsOisDefined, _lhsOisMultiline, _lhsOprecedence, _lhsOpretty)
        )
  )
sem_MaybeMExpr_Nothing :: T_MaybeMExpr
sem_MaybeMExpr_Nothing =
  ( \_lhsIcomments
     _lhsIforceMultiline
     _lhsIindent
     _lhsIppconf ->
        ( let
            _lhsOpretty :: Doc
            _lhsOisDefined :: Bool
            _lhsOendsWithPrefixExpression :: Bool
            _lhsOisMultiline :: Bool
            _lhsOisAssociative :: Bool
            _lhsOprecedence :: OperatorLevel
            _lhsOcopy :: MaybeMExpr
            _lhsOcomments :: ([MToken])
            _lhsOpretty =
              ( empty
              )
            _lhsOisDefined =
              ( False
              )
            _lhsOendsWithPrefixExpression =
              ( False
              )
            _lhsOisMultiline =
              ( False
              )
            _lhsOisAssociative =
              ( False
              )
            _lhsOprecedence =
              ( OperatorLevel8
              )
            _copy =
              ( Nothing
              )
            _lhsOcopy =
              ( _copy
              )
            _lhsOcomments =
              ( _lhsIcomments
              )
          in
            (_lhsOcomments, _lhsOcopy, _lhsOendsWithPrefixExpression, _lhsOisAssociative, _lhsOisDefined, _lhsOisMultiline, _lhsOprecedence, _lhsOpretty)
        )
  )

-- PFExprSuffix ------------------------------------------------
-- cata
sem_PFExprSuffix
  :: PFExprSuffix
  -> T_PFExprSuffix
sem_PFExprSuffix (Call _args) =
  (sem_PFExprSuffix_Call (sem_Args _args))
sem_PFExprSuffix (MetaCall _fn _args) =
  (sem_PFExprSuffix_MetaCall _fn (sem_Args _args))
sem_PFExprSuffix (ExprIndex _index) =
  (sem_PFExprSuffix_ExprIndex (sem_MExpr _index))
sem_PFExprSuffix (DotIndex _index) =
  (sem_PFExprSuffix_DotIndex _index)

-- semantic domain
type T_PFExprSuffix =
  ([MToken])
  -> Bool
  -> Int
  -> PrettyPrintConfig
  -> (([MToken]), PFExprSuffix, Bool, Bool, OperatorLevel, Doc)
data Inh_PFExprSuffix = Inh_PFExprSuffix {comments_Inh_PFExprSuffix :: ([MToken]), forceMultiline_Inh_PFExprSuffix :: Bool, indent_Inh_PFExprSuffix :: Int, ppconf_Inh_PFExprSuffix :: PrettyPrintConfig}
data Syn_PFExprSuffix = Syn_PFExprSuffix {comments_Syn_PFExprSuffix :: ([MToken]), copy_Syn_PFExprSuffix :: PFExprSuffix, isAssociative_Syn_PFExprSuffix :: Bool, isMultiline_Syn_PFExprSuffix :: Bool, precedence_Syn_PFExprSuffix :: OperatorLevel, pretty_Syn_PFExprSuffix :: Doc}
wrap_PFExprSuffix
  :: T_PFExprSuffix
  -> Inh_PFExprSuffix
  -> Syn_PFExprSuffix
wrap_PFExprSuffix sem (Inh_PFExprSuffix _lhsIcomments _lhsIforceMultiline _lhsIindent _lhsIppconf) =
  ( let
      (_lhsOcomments, _lhsOcopy, _lhsOisAssociative, _lhsOisMultiline, _lhsOprecedence, _lhsOpretty) = sem _lhsIcomments _lhsIforceMultiline _lhsIindent _lhsIppconf
    in
      (Syn_PFExprSuffix _lhsOcomments _lhsOcopy _lhsOisAssociative _lhsOisMultiline _lhsOprecedence _lhsOpretty)
  )
sem_PFExprSuffix_Call
  :: T_Args
  -> T_PFExprSuffix
sem_PFExprSuffix_Call args_ =
  ( \_lhsIcomments
     _lhsIforceMultiline
     _lhsIindent
     _lhsIppconf ->
        ( let
            _lhsOpretty :: Doc
            _lhsOisMultiline :: Bool
            _lhsOisAssociative :: Bool
            _lhsOprecedence :: OperatorLevel
            _lhsOcopy :: PFExprSuffix
            _lhsOcomments :: ([MToken])
            _argsOcomments :: ([MToken])
            _argsOforceMultiline :: Bool
            _argsOindent :: Int
            _argsOppconf :: PrettyPrintConfig
            _argsIcomments :: ([MToken])
            _argsIcopy :: Args
            _argsIisMultiline :: Bool
            _argsIpretty :: Doc
            _lhsOpretty =
              ( _argsIpretty
              )
            _lhsOisMultiline =
              ( _argsIisMultiline
              )
            _lhsOisAssociative =
              ( False
              )
            _lhsOprecedence =
              ( OperatorLevel8
              )
            _copy =
              ( Call _argsIcopy
              )
            _lhsOcopy =
              ( _copy
              )
            _lhsOcomments =
              ( _argsIcomments
              )
            _argsOcomments =
              ( _lhsIcomments
              )
            _argsOforceMultiline =
              ( _lhsIforceMultiline
              )
            _argsOindent =
              ( _lhsIindent
              )
            _argsOppconf =
              ( _lhsIppconf
              )
            (_argsIcomments, _argsIcopy, _argsIisMultiline, _argsIpretty) =
              args_ _argsOcomments _argsOforceMultiline _argsOindent _argsOppconf
          in
            (_lhsOcomments, _lhsOcopy, _lhsOisAssociative, _lhsOisMultiline, _lhsOprecedence, _lhsOpretty)
        )
  )
sem_PFExprSuffix_MetaCall
  :: MToken
  -> T_Args
  -> T_PFExprSuffix
sem_PFExprSuffix_MetaCall fn_ args_ =
  ( \_lhsIcomments
     _lhsIforceMultiline
     _lhsIindent
     _lhsIppconf ->
        ( let
            _lhsOpretty :: Doc
            _lhsOisMultiline :: Bool
            _lhsOisAssociative :: Bool
            _lhsOprecedence :: OperatorLevel
            _lhsOcopy :: PFExprSuffix
            _lhsOcomments :: ([MToken])
            _argsOcomments :: ([MToken])
            _argsOforceMultiline :: Bool
            _argsOindent :: Int
            _argsOppconf :: PrettyPrintConfig
            _argsIcomments :: ([MToken])
            _argsIcopy :: Args
            _argsIisMultiline :: Bool
            _argsIpretty :: Doc
            _lhsOpretty =
              ( zchr ':' <> tok fn_ <> _argsIpretty
              )
            _lhsOisMultiline =
              ( _argsIisMultiline
              )
            _lhsOisAssociative =
              ( False
              )
            _lhsOprecedence =
              ( OperatorLevel8
              )
            _copy =
              ( MetaCall fn_ _argsIcopy
              )
            _lhsOcopy =
              ( _copy
              )
            _lhsOcomments =
              ( _argsIcomments
              )
            _argsOcomments =
              ( _lhsIcomments
              )
            _argsOforceMultiline =
              ( _lhsIforceMultiline
              )
            _argsOindent =
              ( _lhsIindent
              )
            _argsOppconf =
              ( _lhsIppconf
              )
            (_argsIcomments, _argsIcopy, _argsIisMultiline, _argsIpretty) =
              args_ _argsOcomments _argsOforceMultiline _argsOindent _argsOppconf
          in
            (_lhsOcomments, _lhsOcopy, _lhsOisAssociative, _lhsOisMultiline, _lhsOprecedence, _lhsOpretty)
        )
  )
sem_PFExprSuffix_ExprIndex
  :: T_MExpr
  -> T_PFExprSuffix
sem_PFExprSuffix_ExprIndex index_ =
  ( \_lhsIcomments
     _lhsIforceMultiline
     _lhsIindent
     _lhsIppconf ->
        ( let
            _lhsOpretty :: Doc
            _lhsOisMultiline :: Bool
            _indexOparentOperatorPrecedence :: OperatorLevel
            _indexOparentOperatorAssociative :: Bool
            _lhsOisAssociative :: Bool
            _lhsOprecedence :: OperatorLevel
            _lhsOcopy :: PFExprSuffix
            _lhsOcomments :: ([MToken])
            _indexOcomments :: ([MToken])
            _indexOforceMultiline :: Bool
            _indexOindent :: Int
            _indexOppconf :: PrettyPrintConfig
            _indexIcomments :: ([MToken])
            _indexIcopy :: MExpr
            _indexIendsWithPrefixExpression :: Bool
            _indexIisAssociative :: Bool
            _indexIisLiteral :: Bool
            _indexIisMultiline :: Bool
            _indexIpos :: Region
            _indexIprecedence :: OperatorLevel
            _indexIpretty :: Doc
            _lhsOpretty =
              ( brackets _lhsIppconf _indexIpretty
              )
            _lhsOisMultiline =
              ( _indexIisMultiline
              )
            _indexOparentOperatorPrecedence =
              ( TopLevelExpression
              )
            _indexOparentOperatorAssociative =
              ( True
              )
            _lhsOisAssociative =
              ( _indexIisAssociative
              )
            _lhsOprecedence =
              ( _indexIprecedence
              )
            _copy =
              ( ExprIndex _indexIcopy
              )
            _lhsOcopy =
              ( _copy
              )
            _lhsOcomments =
              ( _indexIcomments
              )
            _indexOcomments =
              ( _lhsIcomments
              )
            _indexOforceMultiline =
              ( _lhsIforceMultiline
              )
            _indexOindent =
              ( _lhsIindent
              )
            _indexOppconf =
              ( _lhsIppconf
              )
            (_indexIcomments, _indexIcopy, _indexIendsWithPrefixExpression, _indexIisAssociative, _indexIisLiteral, _indexIisMultiline, _indexIpos, _indexIprecedence, _indexIpretty) =
              index_ _indexOcomments _indexOforceMultiline _indexOindent _indexOparentOperatorAssociative _indexOparentOperatorPrecedence _indexOppconf
          in
            (_lhsOcomments, _lhsOcopy, _lhsOisAssociative, _lhsOisMultiline, _lhsOprecedence, _lhsOpretty)
        )
  )
sem_PFExprSuffix_DotIndex
  :: MToken
  -> T_PFExprSuffix
sem_PFExprSuffix_DotIndex index_ =
  ( \_lhsIcomments
     _lhsIforceMultiline
     _lhsIindent
     _lhsIppconf ->
        ( let
            _lhsOpretty :: Doc
            _lhsOisMultiline :: Bool
            _lhsOisAssociative :: Bool
            _lhsOprecedence :: OperatorLevel
            _lhsOcopy :: PFExprSuffix
            _lhsOcomments :: ([MToken])
            _lhsOpretty =
              ( zchr '.' <> tok index_
              )
            _lhsOisMultiline =
              ( False
              )
            _lhsOisAssociative =
              ( False
              )
            _lhsOprecedence =
              ( OperatorLevel8
              )
            _copy =
              ( DotIndex index_
              )
            _lhsOcopy =
              ( _copy
              )
            _lhsOcomments =
              ( _lhsIcomments
              )
          in
            (_lhsOcomments, _lhsOcopy, _lhsOisAssociative, _lhsOisMultiline, _lhsOprecedence, _lhsOpretty)
        )
  )

-- PrefixExp ---------------------------------------------------
-- cata
sem_PrefixExp
  :: PrefixExp
  -> T_PrefixExp
sem_PrefixExp (PFVar _name _suffixes) =
  (sem_PrefixExp_PFVar _name (sem_ExprSuffixList _suffixes))
sem_PrefixExp (ExprVar _expr _suffixes) =
  (sem_PrefixExp_ExprVar (sem_MExpr _expr) (sem_ExprSuffixList _suffixes))

-- semantic domain
type T_PrefixExp =
  ([MToken])
  -> Bool
  -> Int
  -> Bool
  -> OperatorLevel
  -> PrettyPrintConfig
  -> (([MToken]), PrefixExp, Bool, Bool, Bool, OperatorLevel, Doc, Bool)
data Inh_PrefixExp = Inh_PrefixExp {comments_Inh_PrefixExp :: ([MToken]), forceMultiline_Inh_PrefixExp :: Bool, indent_Inh_PrefixExp :: Int, parentOperatorAssociative_Inh_PrefixExp :: Bool, parentOperatorPrecedence_Inh_PrefixExp :: OperatorLevel, ppconf_Inh_PrefixExp :: PrettyPrintConfig}
data Syn_PrefixExp = Syn_PrefixExp {comments_Syn_PrefixExp :: ([MToken]), copy_Syn_PrefixExp :: PrefixExp, isAssociative_Syn_PrefixExp :: Bool, isLiteral_Syn_PrefixExp :: Bool, isMultiline_Syn_PrefixExp :: Bool, precedence_Syn_PrefixExp :: OperatorLevel, pretty_Syn_PrefixExp :: Doc, startsWithExprPrefixExpression_Syn_PrefixExp :: Bool}
wrap_PrefixExp
  :: T_PrefixExp
  -> Inh_PrefixExp
  -> Syn_PrefixExp
wrap_PrefixExp sem (Inh_PrefixExp _lhsIcomments _lhsIforceMultiline _lhsIindent _lhsIparentOperatorAssociative _lhsIparentOperatorPrecedence _lhsIppconf) =
  ( let
      (_lhsOcomments, _lhsOcopy, _lhsOisAssociative, _lhsOisLiteral, _lhsOisMultiline, _lhsOprecedence, _lhsOpretty, _lhsOstartsWithExprPrefixExpression) = sem _lhsIcomments _lhsIforceMultiline _lhsIindent _lhsIparentOperatorAssociative _lhsIparentOperatorPrecedence _lhsIppconf
    in
      (Syn_PrefixExp _lhsOcomments _lhsOcopy _lhsOisAssociative _lhsOisLiteral _lhsOisMultiline _lhsOprecedence _lhsOpretty _lhsOstartsWithExprPrefixExpression)
  )
sem_PrefixExp_PFVar
  :: MToken
  -> T_ExprSuffixList
  -> T_PrefixExp
sem_PrefixExp_PFVar name_ suffixes_ =
  ( \_lhsIcomments
     _lhsIforceMultiline
     _lhsIindent
     _lhsIparentOperatorAssociative
     _lhsIparentOperatorPrecedence
     _lhsIppconf ->
        ( let
            _lhsOpretty :: Doc
            _lhsOisLiteral :: Bool
            _lhsOstartsWithExprPrefixExpression :: Bool
            _lhsOisMultiline :: Bool
            _lhsOisAssociative :: Bool
            _lhsOprecedence :: OperatorLevel
            _lhsOcopy :: PrefixExp
            _lhsOcomments :: ([MToken])
            _suffixesOcomments :: ([MToken])
            _suffixesOforceMultiline :: Bool
            _suffixesOindent :: Int
            _suffixesOppconf :: PrettyPrintConfig
            _suffixesIcomments :: ([MToken])
            _suffixesIcopy :: ExprSuffixList
            _suffixesIisAssociative :: Bool
            _suffixesIisMultiline :: Bool
            _suffixesIprecedence :: OperatorLevel
            _suffixesIpretty :: Doc
            _lhsOpretty =
              ( tok name_ <> _suffixesIpretty
              )
            _lhsOisLiteral =
              ( False
              )
            _lhsOstartsWithExprPrefixExpression =
              ( False
              )
            _lhsOisMultiline =
              ( _suffixesIisMultiline
              )
            _lhsOisAssociative =
              ( _suffixesIisAssociative
              )
            _lhsOprecedence =
              ( _suffixesIprecedence
              )
            _copy =
              ( PFVar name_ _suffixesIcopy
              )
            _lhsOcopy =
              ( _copy
              )
            _lhsOcomments =
              ( _suffixesIcomments
              )
            _suffixesOcomments =
              ( _lhsIcomments
              )
            _suffixesOforceMultiline =
              ( _lhsIforceMultiline
              )
            _suffixesOindent =
              ( _lhsIindent
              )
            _suffixesOppconf =
              ( _lhsIppconf
              )
            (_suffixesIcomments, _suffixesIcopy, _suffixesIisAssociative, _suffixesIisMultiline, _suffixesIprecedence, _suffixesIpretty) =
              suffixes_ _suffixesOcomments _suffixesOforceMultiline _suffixesOindent _suffixesOppconf
          in
            (_lhsOcomments, _lhsOcopy, _lhsOisAssociative, _lhsOisLiteral, _lhsOisMultiline, _lhsOprecedence, _lhsOpretty, _lhsOstartsWithExprPrefixExpression)
        )
  )
sem_PrefixExp_ExprVar
  :: T_MExpr
  -> T_ExprSuffixList
  -> T_PrefixExp
sem_PrefixExp_ExprVar expr_ suffixes_ =
  ( \_lhsIcomments
     _lhsIforceMultiline
     _lhsIindent
     _lhsIparentOperatorAssociative
     _lhsIparentOperatorPrecedence
     _lhsIppconf ->
        ( let
            _lhsOpretty :: Doc
            _lhsOprecedence :: OperatorLevel
            _lhsOisLiteral :: Bool
            _lhsOstartsWithExprPrefixExpression :: Bool
            _lhsOisMultiline :: Bool
            _lhsOisAssociative :: Bool
            _lhsOcopy :: PrefixExp
            _lhsOcomments :: ([MToken])
            _exprOcomments :: ([MToken])
            _exprOforceMultiline :: Bool
            _exprOindent :: Int
            _exprOparentOperatorAssociative :: Bool
            _exprOparentOperatorPrecedence :: OperatorLevel
            _exprOppconf :: PrettyPrintConfig
            _suffixesOcomments :: ([MToken])
            _suffixesOforceMultiline :: Bool
            _suffixesOindent :: Int
            _suffixesOppconf :: PrettyPrintConfig
            _exprIcomments :: ([MToken])
            _exprIcopy :: MExpr
            _exprIendsWithPrefixExpression :: Bool
            _exprIisAssociative :: Bool
            _exprIisLiteral :: Bool
            _exprIisMultiline :: Bool
            _exprIpos :: Region
            _exprIprecedence :: OperatorLevel
            _exprIpretty :: Doc
            _suffixesIcomments :: ([MToken])
            _suffixesIcopy :: ExprSuffixList
            _suffixesIisAssociative :: Bool
            _suffixesIisMultiline :: Bool
            _suffixesIprecedence :: OperatorLevel
            _suffixesIpretty :: Doc
            _lhsOpretty =
              ( (if _noparens then _exprIpretty else parens _lhsIppconf NonEmpty _exprIpretty)
                  <> _suffixesIpretty
              )
            _lhsOprecedence =
              ( if _noparens then _exprIprecedence else OperatorLevel8
              )
            _lhsOisLiteral =
              ( False
              )
            _lhsOstartsWithExprPrefixExpression =
              ( True
              )
            _lhsOisMultiline =
              ( _exprIisMultiline || _suffixesIisMultiline
              )
            _containsParenthesizedExpr =
              ( case _exprIcopy of
                  MExpr _ (APrefixExpr (ExprVar (MExpr _ AVarArg) _)) -> False
                  MExpr _ (APrefixExpr _) -> True
                  _ -> False
              )
            _noparens =
              ( (removeRedundantParens _lhsIppconf || minimizeParens _lhsIppconf)
                  && ( _containsParenthesizedExpr
                        || (_lhsIparentOperatorPrecedence == TopLevelExpression || _exprIisLiteral)
                          && length _suffixesIcopy == 0
                     )
                  || ( minimizeParens _lhsIppconf
                        && length _suffixesIcopy == 0
                        && ( _lhsIparentOperatorPrecedence < _exprIprecedence
                              || assumeOperatorAssociativity _lhsIppconf
                                && _lhsIparentOperatorPrecedence == _exprIprecedence
                                && _lhsIparentOperatorAssociative
                           )
                     )
              )
            _lhsOisAssociative =
              ( _exprIisAssociative && _suffixesIisAssociative
              )
            _copy =
              ( ExprVar _exprIcopy _suffixesIcopy
              )
            _lhsOcopy =
              ( _copy
              )
            _lhsOcomments =
              ( _suffixesIcomments
              )
            _exprOcomments =
              ( _lhsIcomments
              )
            _exprOforceMultiline =
              ( _lhsIforceMultiline
              )
            _exprOindent =
              ( _lhsIindent
              )
            _exprOparentOperatorAssociative =
              ( _lhsIparentOperatorAssociative
              )
            _exprOparentOperatorPrecedence =
              ( _lhsIparentOperatorPrecedence
              )
            _exprOppconf =
              ( _lhsIppconf
              )
            _suffixesOcomments =
              ( _exprIcomments
              )
            _suffixesOforceMultiline =
              ( _lhsIforceMultiline
              )
            _suffixesOindent =
              ( _lhsIindent
              )
            _suffixesOppconf =
              ( _lhsIppconf
              )
            (_exprIcomments, _exprIcopy, _exprIendsWithPrefixExpression, _exprIisAssociative, _exprIisLiteral, _exprIisMultiline, _exprIpos, _exprIprecedence, _exprIpretty) =
              expr_ _exprOcomments _exprOforceMultiline _exprOindent _exprOparentOperatorAssociative _exprOparentOperatorPrecedence _exprOppconf
            (_suffixesIcomments, _suffixesIcopy, _suffixesIisAssociative, _suffixesIisMultiline, _suffixesIprecedence, _suffixesIpretty) =
              suffixes_ _suffixesOcomments _suffixesOforceMultiline _suffixesOindent _suffixesOppconf
          in
            (_lhsOcomments, _lhsOcopy, _lhsOisAssociative, _lhsOisLiteral, _lhsOisMultiline, _lhsOprecedence, _lhsOpretty, _lhsOstartsWithExprPrefixExpression)
        )
  )

-- Stat --------------------------------------------------------
-- cata
sem_Stat
  :: Stat
  -> T_Stat
sem_Stat (Def _vars) =
  (sem_Stat_Def (sem_VarsList _vars))
sem_Stat (LocDef _vars) =
  (sem_Stat_LocDef (sem_VarsList _vars))
sem_Stat (AFuncCall _fn) =
  (sem_Stat_AFuncCall (sem_PrefixExp _fn))
sem_Stat (ALabel _lbl) =
  (sem_Stat_ALabel _lbl)
sem_Stat (ABreak) =
  (sem_Stat_ABreak)
sem_Stat (AContinue) =
  (sem_Stat_AContinue)
sem_Stat (AGoto _lbl) =
  (sem_Stat_AGoto _lbl)
sem_Stat (ADo _body) =
  (sem_Stat_ADo (sem_Block _body))
sem_Stat (AWhile _cond _body) =
  (sem_Stat_AWhile (sem_MExpr _cond) (sem_Block _body))
sem_Stat (ARepeat _body _cond) =
  (sem_Stat_ARepeat (sem_Block _body) (sem_MExpr _cond))
sem_Stat (AIf _cond _body _elifs _els) =
  (sem_Stat_AIf (sem_MExpr _cond) (sem_Block _body) (sem_ElseIfList _elifs) (sem_Else _els))
sem_Stat (ANFor _var _val _to _step _body) =
  (sem_Stat_ANFor _var (sem_MExpr _val) (sem_MExpr _to) (sem_MExpr _step) (sem_Block _body))
sem_Stat (AGFor _vars _vals _body) =
  (sem_Stat_AGFor _vars (sem_MExprList _vals) (sem_Block _body))
sem_Stat (AFunc _name _args _body) =
  (sem_Stat_AFunc (sem_FuncName _name) _args (sem_Block _body))
sem_Stat (ALocFunc _name _args _body) =
  (sem_Stat_ALocFunc (sem_FuncName _name) _args (sem_Block _body))

-- semantic domain
type T_Stat =
  ([MToken])
  -> Bool
  -> Int
  -> Bool
  -> PrettyPrintConfig
  -> Region
  -> Bool
  -> (([MToken]), Stat, Bool, Bool, Doc, Bool)
data Inh_Stat = Inh_Stat {comments_Inh_Stat :: ([MToken]), forceMultiline_Inh_Stat :: Bool, indent_Inh_Stat :: Int, isLastStatement_Inh_Stat :: Bool, ppconf_Inh_Stat :: PrettyPrintConfig, statRegion_Inh_Stat :: Region, wouldBeAmbiguousWithoutSemicolon_Inh_Stat :: Bool}
data Syn_Stat = Syn_Stat {comments_Syn_Stat :: ([MToken]), copy_Syn_Stat :: Stat, endsWithPrefixExpression_Syn_Stat :: Bool, isMultiline_Syn_Stat :: Bool, pretty_Syn_Stat :: Doc, startsWithExprPrefixExpression_Syn_Stat :: Bool}
wrap_Stat
  :: T_Stat
  -> Inh_Stat
  -> Syn_Stat
wrap_Stat sem (Inh_Stat _lhsIcomments _lhsIforceMultiline _lhsIindent _lhsIisLastStatement _lhsIppconf _lhsIstatRegion _lhsIwouldBeAmbiguousWithoutSemicolon) =
  ( let
      (_lhsOcomments, _lhsOcopy, _lhsOendsWithPrefixExpression, _lhsOisMultiline, _lhsOpretty, _lhsOstartsWithExprPrefixExpression) = sem _lhsIcomments _lhsIforceMultiline _lhsIindent _lhsIisLastStatement _lhsIppconf _lhsIstatRegion _lhsIwouldBeAmbiguousWithoutSemicolon
    in
      (Syn_Stat _lhsOcomments _lhsOcopy _lhsOendsWithPrefixExpression _lhsOisMultiline _lhsOpretty _lhsOstartsWithExprPrefixExpression)
  )
sem_Stat_Def
  :: T_VarsList
  -> T_Stat
sem_Stat_Def vars_ =
  ( \_lhsIcomments
     _lhsIforceMultiline
     _lhsIindent
     _lhsIisLastStatement
     _lhsIppconf
     _lhsIstatRegion
     _lhsIwouldBeAmbiguousWithoutSemicolon ->
        ( let
            _lhsOpretty :: Doc
            _lhsOstartsWithExprPrefixExpression :: Bool
            _lhsOendsWithPrefixExpression :: Bool
            _lhsOisMultiline :: Bool
            _lhsOcopy :: Stat
            _lhsOcomments :: ([MToken])
            _varsOcomments :: ([MToken])
            _varsOforceMultiline :: Bool
            _varsOindent :: Int
            _varsOppconf :: PrettyPrintConfig
            _varsIcomments :: ([MToken])
            _varsIcopy :: VarsList
            _varsIendsWithPrefixExpression :: Bool
            _varsIexprPretty :: Doc
            _varsIisDefined :: Bool
            _varsIisLast :: Bool
            _varsIisMultiline :: Bool
            _varsIpretty :: Doc
            _varsIstartsWithExprPrefixExpression :: Bool
            _varsIvarPretty :: Doc
            _lhsOpretty =
              ( _varsIpretty <> _semicolon
              )
            _lhsOstartsWithExprPrefixExpression =
              ( _varsIstartsWithExprPrefixExpression
              )
            _lhsOendsWithPrefixExpression =
              ( _varsIendsWithPrefixExpression
              )
            _lhsOisMultiline =
              ( _varsIisMultiline
              )
            _semicolon =
              ( if semicolons _lhsIppconf || _lhsIwouldBeAmbiguousWithoutSemicolon
                  then zchr ';'
                  else empty
              )
            _copy =
              ( Def _varsIcopy
              )
            _lhsOcopy =
              ( _copy
              )
            _lhsOcomments =
              ( _varsIcomments
              )
            _varsOcomments =
              ( _lhsIcomments
              )
            _varsOforceMultiline =
              ( _lhsIforceMultiline
              )
            _varsOindent =
              ( _lhsIindent
              )
            _varsOppconf =
              ( _lhsIppconf
              )
            (_varsIcomments, _varsIcopy, _varsIendsWithPrefixExpression, _varsIexprPretty, _varsIisDefined, _varsIisLast, _varsIisMultiline, _varsIpretty, _varsIstartsWithExprPrefixExpression, _varsIvarPretty) =
              vars_ _varsOcomments _varsOforceMultiline _varsOindent _varsOppconf
          in
            (_lhsOcomments, _lhsOcopy, _lhsOendsWithPrefixExpression, _lhsOisMultiline, _lhsOpretty, _lhsOstartsWithExprPrefixExpression)
        )
  )
sem_Stat_LocDef
  :: T_VarsList
  -> T_Stat
sem_Stat_LocDef vars_ =
  ( \_lhsIcomments
     _lhsIforceMultiline
     _lhsIindent
     _lhsIisLastStatement
     _lhsIppconf
     _lhsIstatRegion
     _lhsIwouldBeAmbiguousWithoutSemicolon ->
        ( let
            _lhsOpretty :: Doc
            _lhsOstartsWithExprPrefixExpression :: Bool
            _lhsOendsWithPrefixExpression :: Bool
            _lhsOisMultiline :: Bool
            _lhsOcopy :: Stat
            _lhsOcomments :: ([MToken])
            _varsOcomments :: ([MToken])
            _varsOforceMultiline :: Bool
            _varsOindent :: Int
            _varsOppconf :: PrettyPrintConfig
            _varsIcomments :: ([MToken])
            _varsIcopy :: VarsList
            _varsIendsWithPrefixExpression :: Bool
            _varsIexprPretty :: Doc
            _varsIisDefined :: Bool
            _varsIisLast :: Bool
            _varsIisMultiline :: Bool
            _varsIpretty :: Doc
            _varsIstartsWithExprPrefixExpression :: Bool
            _varsIvarPretty :: Doc
            _lhsOpretty =
              ( zeroWidthText "local" <-> _varsIpretty <> _semicolon
              )
            _lhsOstartsWithExprPrefixExpression =
              ( _varsIstartsWithExprPrefixExpression
              )
            _lhsOendsWithPrefixExpression =
              ( _varsIendsWithPrefixExpression
              )
            _lhsOisMultiline =
              ( _varsIisMultiline
              )
            _semicolon =
              ( if semicolons _lhsIppconf || _lhsIwouldBeAmbiguousWithoutSemicolon
                  then zchr ';'
                  else empty
              )
            _copy =
              ( LocDef _varsIcopy
              )
            _lhsOcopy =
              ( _copy
              )
            _lhsOcomments =
              ( _varsIcomments
              )
            _varsOcomments =
              ( _lhsIcomments
              )
            _varsOforceMultiline =
              ( _lhsIforceMultiline
              )
            _varsOindent =
              ( _lhsIindent
              )
            _varsOppconf =
              ( _lhsIppconf
              )
            (_varsIcomments, _varsIcopy, _varsIendsWithPrefixExpression, _varsIexprPretty, _varsIisDefined, _varsIisLast, _varsIisMultiline, _varsIpretty, _varsIstartsWithExprPrefixExpression, _varsIvarPretty) =
              vars_ _varsOcomments _varsOforceMultiline _varsOindent _varsOppconf
          in
            (_lhsOcomments, _lhsOcopy, _lhsOendsWithPrefixExpression, _lhsOisMultiline, _lhsOpretty, _lhsOstartsWithExprPrefixExpression)
        )
  )
sem_Stat_AFuncCall
  :: T_PrefixExp
  -> T_Stat
sem_Stat_AFuncCall fn_ =
  ( \_lhsIcomments
     _lhsIforceMultiline
     _lhsIindent
     _lhsIisLastStatement
     _lhsIppconf
     _lhsIstatRegion
     _lhsIwouldBeAmbiguousWithoutSemicolon ->
        ( let
            _lhsOpretty :: Doc
            _lhsOisMultiline :: Bool
            _lhsOstartsWithExprPrefixExpression :: Bool
            _lhsOendsWithPrefixExpression :: Bool
            _fnOparentOperatorPrecedence :: OperatorLevel
            _fnOparentOperatorAssociative :: Bool
            _lhsOcopy :: Stat
            _lhsOcomments :: ([MToken])
            _fnOcomments :: ([MToken])
            _fnOforceMultiline :: Bool
            _fnOindent :: Int
            _fnOppconf :: PrettyPrintConfig
            _fnIcomments :: ([MToken])
            _fnIcopy :: PrefixExp
            _fnIisAssociative :: Bool
            _fnIisLiteral :: Bool
            _fnIisMultiline :: Bool
            _fnIprecedence :: OperatorLevel
            _fnIpretty :: Doc
            _fnIstartsWithExprPrefixExpression :: Bool
            _lhsOpretty =
              ( _fnIpretty <> _semicolon
              )
            _lhsOisMultiline =
              ( _fnIisMultiline
              )
            _semicolon =
              ( if semicolons _lhsIppconf then zchr ';' else empty
              )
            _lhsOstartsWithExprPrefixExpression =
              ( _fnIstartsWithExprPrefixExpression
              )
            _lhsOendsWithPrefixExpression =
              ( True
              )
            _fnOparentOperatorPrecedence =
              ( TopLevelExpression
              )
            _fnOparentOperatorAssociative =
              ( True
              )
            _copy =
              ( AFuncCall _fnIcopy
              )
            _lhsOcopy =
              ( _copy
              )
            _lhsOcomments =
              ( _fnIcomments
              )
            _fnOcomments =
              ( _lhsIcomments
              )
            _fnOforceMultiline =
              ( _lhsIforceMultiline
              )
            _fnOindent =
              ( _lhsIindent
              )
            _fnOppconf =
              ( _lhsIppconf
              )
            (_fnIcomments, _fnIcopy, _fnIisAssociative, _fnIisLiteral, _fnIisMultiline, _fnIprecedence, _fnIpretty, _fnIstartsWithExprPrefixExpression) =
              fn_ _fnOcomments _fnOforceMultiline _fnOindent _fnOparentOperatorAssociative _fnOparentOperatorPrecedence _fnOppconf
          in
            (_lhsOcomments, _lhsOcopy, _lhsOendsWithPrefixExpression, _lhsOisMultiline, _lhsOpretty, _lhsOstartsWithExprPrefixExpression)
        )
  )
sem_Stat_ALabel
  :: MToken
  -> T_Stat
sem_Stat_ALabel lbl_ =
  ( \_lhsIcomments
     _lhsIforceMultiline
     _lhsIindent
     _lhsIisLastStatement
     _lhsIppconf
     _lhsIstatRegion
     _lhsIwouldBeAmbiguousWithoutSemicolon ->
        ( let
            _lhsOpretty :: Doc
            _lhsOstartsWithExprPrefixExpression :: Bool
            _lhsOendsWithPrefixExpression :: Bool
            _lhsOisMultiline :: Bool
            _lhsOcopy :: Stat
            _lhsOcomments :: ([MToken])
            _lhsOpretty =
              ( zeroWidthText "::"
                  <> _whitespace
                  <> tok lbl_
                  <> _whitespace
                  <> zeroWidthText "::"
              )
            _lhsOstartsWithExprPrefixExpression =
              ( False
              )
            _lhsOendsWithPrefixExpression =
              ( False
              )
            _lhsOisMultiline =
              ( False
              )
            _whitespace =
              ( if spaceAfterLabel _lhsIppconf then zeroWidthText " " else empty
              )
            _copy =
              ( ALabel lbl_
              )
            _lhsOcopy =
              ( _copy
              )
            _lhsOcomments =
              ( _lhsIcomments
              )
          in
            (_lhsOcomments, _lhsOcopy, _lhsOendsWithPrefixExpression, _lhsOisMultiline, _lhsOpretty, _lhsOstartsWithExprPrefixExpression)
        )
  )
sem_Stat_ABreak :: T_Stat
sem_Stat_ABreak =
  ( \_lhsIcomments
     _lhsIforceMultiline
     _lhsIindent
     _lhsIisLastStatement
     _lhsIppconf
     _lhsIstatRegion
     _lhsIwouldBeAmbiguousWithoutSemicolon ->
        ( let
            _lhsOpretty :: Doc
            _lhsOstartsWithExprPrefixExpression :: Bool
            _lhsOendsWithPrefixExpression :: Bool
            _lhsOisMultiline :: Bool
            _lhsOcopy :: Stat
            _lhsOcomments :: ([MToken])
            _lhsOpretty =
              ( zeroWidthText "break" <> _semicolon
              )
            _lhsOstartsWithExprPrefixExpression =
              ( False
              )
            _lhsOendsWithPrefixExpression =
              ( False
              )
            _lhsOisMultiline =
              ( False
              )
            _semicolon =
              ( if semicolons _lhsIppconf then zchr ';' else empty
              )
            _copy =
              ( ABreak
              )
            _lhsOcopy =
              ( _copy
              )
            _lhsOcomments =
              ( _lhsIcomments
              )
          in
            (_lhsOcomments, _lhsOcopy, _lhsOendsWithPrefixExpression, _lhsOisMultiline, _lhsOpretty, _lhsOstartsWithExprPrefixExpression)
        )
  )
sem_Stat_AContinue :: T_Stat
sem_Stat_AContinue =
  ( \_lhsIcomments
     _lhsIforceMultiline
     _lhsIindent
     _lhsIisLastStatement
     _lhsIppconf
     _lhsIstatRegion
     _lhsIwouldBeAmbiguousWithoutSemicolon ->
        ( let
            _lhsOpretty :: Doc
            _lhsOstartsWithExprPrefixExpression :: Bool
            _lhsOendsWithPrefixExpression :: Bool
            _lhsOisMultiline :: Bool
            _lhsOcopy :: Stat
            _lhsOcomments :: ([MToken])
            _lhsOpretty =
              ( zeroWidthText "continue" <> _semicolon
              )
            _lhsOstartsWithExprPrefixExpression =
              ( False
              )
            _lhsOendsWithPrefixExpression =
              ( False
              )
            _lhsOisMultiline =
              ( False
              )
            _semicolon =
              ( if semicolons _lhsIppconf then zchr ';' else empty
              )
            _copy =
              ( AContinue
              )
            _lhsOcopy =
              ( _copy
              )
            _lhsOcomments =
              ( _lhsIcomments
              )
          in
            (_lhsOcomments, _lhsOcopy, _lhsOendsWithPrefixExpression, _lhsOisMultiline, _lhsOpretty, _lhsOstartsWithExprPrefixExpression)
        )
  )
sem_Stat_AGoto
  :: MToken
  -> T_Stat
sem_Stat_AGoto lbl_ =
  ( \_lhsIcomments
     _lhsIforceMultiline
     _lhsIindent
     _lhsIisLastStatement
     _lhsIppconf
     _lhsIstatRegion
     _lhsIwouldBeAmbiguousWithoutSemicolon ->
        ( let
            _lhsOpretty :: Doc
            _lhsOstartsWithExprPrefixExpression :: Bool
            _lhsOendsWithPrefixExpression :: Bool
            _lhsOisMultiline :: Bool
            _lhsOcopy :: Stat
            _lhsOcomments :: ([MToken])
            _lhsOpretty =
              ( zeroWidthText "goto" <-> tok lbl_ <> _semicolon
              )
            _lhsOstartsWithExprPrefixExpression =
              ( False
              )
            _lhsOendsWithPrefixExpression =
              ( False
              )
            _lhsOisMultiline =
              ( False
              )
            _semicolon =
              ( if semicolons _lhsIppconf then zchr ';' else empty
              )
            _copy =
              ( AGoto lbl_
              )
            _lhsOcopy =
              ( _copy
              )
            _lhsOcomments =
              ( _lhsIcomments
              )
          in
            (_lhsOcomments, _lhsOcopy, _lhsOendsWithPrefixExpression, _lhsOisMultiline, _lhsOpretty, _lhsOstartsWithExprPrefixExpression)
        )
  )
sem_Stat_ADo
  :: T_Block
  -> T_Stat
sem_Stat_ADo body_ =
  ( \_lhsIcomments
     _lhsIforceMultiline
     _lhsIindent
     _lhsIisLastStatement
     _lhsIppconf
     _lhsIstatRegion
     _lhsIwouldBeAmbiguousWithoutSemicolon ->
        ( let
            _lhsOisMultiline :: Bool
            _lhsOpretty :: Doc
            _lhsOstartsWithExprPrefixExpression :: Bool
            _lhsOendsWithPrefixExpression :: Bool
            _bodyOindent :: Int
            _lhsOcopy :: Stat
            _lhsOcomments :: ([MToken])
            _bodyOcomments :: ([MToken])
            _bodyOforceMultiline :: Bool
            _bodyOppconf :: PrettyPrintConfig
            _bodyOstatRegion :: Region
            _bodyIcomments :: ([MToken])
            _bodyIcopy :: Block
            _bodyIisMultiline :: Bool
            _bodyIpretty :: Doc
            _bodyIstatementCount :: Int
            _lhsOisMultiline =
              ( True
              )
            _lhsOpretty =
              ( zeroWidthText "do"
                  $+$ _bodyIpretty
                  $+$ indent _lhsIppconf _lhsIindent (zeroWidthText "end")
              )
            _lhsOstartsWithExprPrefixExpression =
              ( False
              )
            _lhsOendsWithPrefixExpression =
              ( False
              )
            _bodyOindent =
              ( _lhsIindent + 1
              )
            _copy =
              ( ADo _bodyIcopy
              )
            _lhsOcopy =
              ( _copy
              )
            _lhsOcomments =
              ( _bodyIcomments
              )
            _bodyOcomments =
              ( _lhsIcomments
              )
            _bodyOforceMultiline =
              ( _lhsIforceMultiline
              )
            _bodyOppconf =
              ( _lhsIppconf
              )
            _bodyOstatRegion =
              ( _lhsIstatRegion
              )
            (_bodyIcomments, _bodyIcopy, _bodyIisMultiline, _bodyIpretty, _bodyIstatementCount) =
              body_ _bodyOcomments _bodyOforceMultiline _bodyOindent _bodyOppconf _bodyOstatRegion
          in
            (_lhsOcomments, _lhsOcopy, _lhsOendsWithPrefixExpression, _lhsOisMultiline, _lhsOpretty, _lhsOstartsWithExprPrefixExpression)
        )
  )
sem_Stat_AWhile
  :: T_MExpr
  -> T_Block
  -> T_Stat
sem_Stat_AWhile cond_ body_ =
  ( \_lhsIcomments
     _lhsIforceMultiline
     _lhsIindent
     _lhsIisLastStatement
     _lhsIppconf
     _lhsIstatRegion
     _lhsIwouldBeAmbiguousWithoutSemicolon ->
        ( let
            _lhsOisMultiline :: Bool
            _lhsOstartsWithExprPrefixExpression :: Bool
            _lhsOendsWithPrefixExpression :: Bool
            _condOparentOperatorPrecedence :: OperatorLevel
            _condOparentOperatorAssociative :: Bool
            _lhsOpretty :: Doc
            _bodyOindent :: Int
            _lhsOcopy :: Stat
            _lhsOcomments :: ([MToken])
            _condOcomments :: ([MToken])
            _condOforceMultiline :: Bool
            _condOindent :: Int
            _condOppconf :: PrettyPrintConfig
            _bodyOcomments :: ([MToken])
            _bodyOforceMultiline :: Bool
            _bodyOppconf :: PrettyPrintConfig
            _bodyOstatRegion :: Region
            _condIcomments :: ([MToken])
            _condIcopy :: MExpr
            _condIendsWithPrefixExpression :: Bool
            _condIisAssociative :: Bool
            _condIisLiteral :: Bool
            _condIisMultiline :: Bool
            _condIpos :: Region
            _condIprecedence :: OperatorLevel
            _condIpretty :: Doc
            _bodyIcomments :: ([MToken])
            _bodyIcopy :: Block
            _bodyIisMultiline :: Bool
            _bodyIpretty :: Doc
            _bodyIstatementCount :: Int
            _lhsOisMultiline =
              ( True
              )
            _lhsOstartsWithExprPrefixExpression =
              ( False
              )
            _lhsOendsWithPrefixExpression =
              ( False
              )
            _condOparentOperatorPrecedence =
              ( TopLevelExpression
              )
            _condOparentOperatorAssociative =
              ( True
              )
            _lhsOpretty =
              ( zeroWidthText "while"
                  <-> _condIpretty
                  <-> zeroWidthText "do"
                  $+$ _bodyIpretty
                  $+$ indent _lhsIppconf _lhsIindent (zeroWidthText "end")
              )
            _bodyOindent =
              ( _lhsIindent + 1
              )
            _copy =
              ( AWhile _condIcopy _bodyIcopy
              )
            _lhsOcopy =
              ( _copy
              )
            _lhsOcomments =
              ( _bodyIcomments
              )
            _condOcomments =
              ( _lhsIcomments
              )
            _condOforceMultiline =
              ( _lhsIforceMultiline
              )
            _condOindent =
              ( _lhsIindent
              )
            _condOppconf =
              ( _lhsIppconf
              )
            _bodyOcomments =
              ( _condIcomments
              )
            _bodyOforceMultiline =
              ( _lhsIforceMultiline
              )
            _bodyOppconf =
              ( _lhsIppconf
              )
            _bodyOstatRegion =
              ( _lhsIstatRegion
              )
            (_condIcomments, _condIcopy, _condIendsWithPrefixExpression, _condIisAssociative, _condIisLiteral, _condIisMultiline, _condIpos, _condIprecedence, _condIpretty) =
              cond_ _condOcomments _condOforceMultiline _condOindent _condOparentOperatorAssociative _condOparentOperatorPrecedence _condOppconf
            (_bodyIcomments, _bodyIcopy, _bodyIisMultiline, _bodyIpretty, _bodyIstatementCount) =
              body_ _bodyOcomments _bodyOforceMultiline _bodyOindent _bodyOppconf _bodyOstatRegion
          in
            (_lhsOcomments, _lhsOcopy, _lhsOendsWithPrefixExpression, _lhsOisMultiline, _lhsOpretty, _lhsOstartsWithExprPrefixExpression)
        )
  )
sem_Stat_ARepeat
  :: T_Block
  -> T_MExpr
  -> T_Stat
sem_Stat_ARepeat body_ cond_ =
  ( \_lhsIcomments
     _lhsIforceMultiline
     _lhsIindent
     _lhsIisLastStatement
     _lhsIppconf
     _lhsIstatRegion
     _lhsIwouldBeAmbiguousWithoutSemicolon ->
        ( let
            _lhsOpretty :: Doc
            _lhsOstartsWithExprPrefixExpression :: Bool
            _lhsOendsWithPrefixExpression :: Bool
            _lhsOisMultiline :: Bool
            _bodyOindent :: Int
            _condOparentOperatorPrecedence :: OperatorLevel
            _condOparentOperatorAssociative :: Bool
            _lhsOcopy :: Stat
            _lhsOcomments :: ([MToken])
            _bodyOcomments :: ([MToken])
            _bodyOforceMultiline :: Bool
            _bodyOppconf :: PrettyPrintConfig
            _bodyOstatRegion :: Region
            _condOcomments :: ([MToken])
            _condOforceMultiline :: Bool
            _condOindent :: Int
            _condOppconf :: PrettyPrintConfig
            _bodyIcomments :: ([MToken])
            _bodyIcopy :: Block
            _bodyIisMultiline :: Bool
            _bodyIpretty :: Doc
            _bodyIstatementCount :: Int
            _condIcomments :: ([MToken])
            _condIcopy :: MExpr
            _condIendsWithPrefixExpression :: Bool
            _condIisAssociative :: Bool
            _condIisLiteral :: Bool
            _condIisMultiline :: Bool
            _condIpos :: Region
            _condIprecedence :: OperatorLevel
            _condIpretty :: Doc
            _lhsOpretty =
              ( zeroWidthText "repeat"
                  $+$ _bodyIpretty
                  $+$ indent _lhsIppconf _lhsIindent (zeroWidthText "until" <-> _condIpretty)
              )
            _lhsOstartsWithExprPrefixExpression =
              ( False
              )
            _lhsOendsWithPrefixExpression =
              ( False
              )
            _lhsOisMultiline =
              ( True
              )
            _bodyOindent =
              ( _lhsIindent + 1
              )
            _condOparentOperatorPrecedence =
              ( TopLevelExpression
              )
            _condOparentOperatorAssociative =
              ( True
              )
            _copy =
              ( ARepeat _bodyIcopy _condIcopy
              )
            _lhsOcopy =
              ( _copy
              )
            _lhsOcomments =
              ( _condIcomments
              )
            _bodyOcomments =
              ( _lhsIcomments
              )
            _bodyOforceMultiline =
              ( _lhsIforceMultiline
              )
            _bodyOppconf =
              ( _lhsIppconf
              )
            _bodyOstatRegion =
              ( _lhsIstatRegion
              )
            _condOcomments =
              ( _bodyIcomments
              )
            _condOforceMultiline =
              ( _lhsIforceMultiline
              )
            _condOindent =
              ( _lhsIindent
              )
            _condOppconf =
              ( _lhsIppconf
              )
            (_bodyIcomments, _bodyIcopy, _bodyIisMultiline, _bodyIpretty, _bodyIstatementCount) =
              body_ _bodyOcomments _bodyOforceMultiline _bodyOindent _bodyOppconf _bodyOstatRegion
            (_condIcomments, _condIcopy, _condIendsWithPrefixExpression, _condIisAssociative, _condIisLiteral, _condIisMultiline, _condIpos, _condIprecedence, _condIpretty) =
              cond_ _condOcomments _condOforceMultiline _condOindent _condOparentOperatorAssociative _condOparentOperatorPrecedence _condOppconf
          in
            (_lhsOcomments, _lhsOcopy, _lhsOendsWithPrefixExpression, _lhsOisMultiline, _lhsOpretty, _lhsOstartsWithExprPrefixExpression)
        )
  )
sem_Stat_AIf
  :: T_MExpr
  -> T_Block
  -> T_ElseIfList
  -> T_Else
  -> T_Stat
sem_Stat_AIf cond_ body_ elifs_ els_ =
  ( \_lhsIcomments
     _lhsIforceMultiline
     _lhsIindent
     _lhsIisLastStatement
     _lhsIppconf
     _lhsIstatRegion
     _lhsIwouldBeAmbiguousWithoutSemicolon ->
        ( let
            _lhsOstartsWithExprPrefixExpression :: Bool
            _lhsOendsWithPrefixExpression :: Bool
            _condOcomments :: ([MToken])
            _condOparentOperatorPrecedence :: OperatorLevel
            _condOparentOperatorAssociative :: Bool
            _bodyOindent :: Int
            _bodyOstatRegion :: Region
            _lhsOpretty :: Doc
            _lhsOcopy :: Stat
            _lhsOcomments :: ([MToken])
            _lhsOisMultiline :: Bool
            _condOforceMultiline :: Bool
            _condOindent :: Int
            _condOppconf :: PrettyPrintConfig
            _bodyOcomments :: ([MToken])
            _bodyOforceMultiline :: Bool
            _bodyOppconf :: PrettyPrintConfig
            _elifsOcomments :: ([MToken])
            _elifsOforceMultiline :: Bool
            _elifsOindent :: Int
            _elifsOppconf :: PrettyPrintConfig
            _elsOcomments :: ([MToken])
            _elsOforceMultiline :: Bool
            _elsOindent :: Int
            _elsOppconf :: PrettyPrintConfig
            _elsOstatRegion :: Region
            _condIcomments :: ([MToken])
            _condIcopy :: MExpr
            _condIendsWithPrefixExpression :: Bool
            _condIisAssociative :: Bool
            _condIisLiteral :: Bool
            _condIisMultiline :: Bool
            _condIpos :: Region
            _condIprecedence :: OperatorLevel
            _condIpretty :: Doc
            _bodyIcomments :: ([MToken])
            _bodyIcopy :: Block
            _bodyIisMultiline :: Bool
            _bodyIpretty :: Doc
            _bodyIstatementCount :: Int
            _elifsIcomments :: ([MToken])
            _elifsIcopy :: ElseIfList
            _elifsIelsesExist :: Bool
            _elifsIisMultiline :: Bool
            _elifsIpos :: Region
            _elifsIpretty :: Doc
            _elsIcomments :: ([MToken])
            _elsIcopy :: Else
            _elsIelsesExist :: Bool
            _elsIisMultiline :: Bool
            _elsIpos :: Region
            _elsIpretty :: Doc
            _isMultiline =
              ( _lhsIforceMultiline
                  || _condIisMultiline
                  || _bodyIisMultiline
                  || _elifsIelsesExist
                  || _elsIelsesExist
              )
            _lhsOstartsWithExprPrefixExpression =
              ( False
              )
            _lhsOendsWithPrefixExpression =
              ( False
              )
            _singleLinePretty =
              ( zeroWidthText "if"
                  <-> _condIpretty
                  <-> zeroWidthText "then"
                  <-> _bodyIpretty
                  <-> zeroWidthText "end"
                  <-> renderSLComments _lhsIppconf _lhsIindent (fst _commentsAfterThen)
              )
            _multilinePretty =
              ( zeroWidthText "if"
                  <-> _condIpretty
                  <-> zeroWidthText "then"
                  <-> renderSLComments _lhsIppconf _lhsIindent (fst _commentsAfterThen)
                  $+$ _bodyIpretty
                  $+$ _elifsIpretty
                  $+$ _elsIpretty
                  $+$ indent _lhsIppconf _lhsIindent (zeroWidthText "end")
              )
            _commentsAfterThen =
              ( span (\(MToken pos _) -> pos `beforeOrOnLine` _condIpos) _lhsIcomments
              )
            _condOcomments =
              ( snd _commentsAfterThen
              )
            _condOparentOperatorPrecedence =
              ( TopLevelExpression
              )
            _condOparentOperatorAssociative =
              ( True
              )
            _bodyOindent =
              ( if _isMultiline then _lhsIindent + 1 else 0
              )
            _bodyOstatRegion =
              ( _lhsIstatRegion `upto` _elifsIpos `upto` _elsIpos
              )
            _lhsOpretty =
              ( if _isMultiline then _multilinePretty else _singleLinePretty
              )
            _copy =
              ( AIf _condIcopy _bodyIcopy _elifsIcopy _elsIcopy
              )
            _lhsOcopy =
              ( _copy
              )
            _lhsOcomments =
              ( _elsIcomments
              )
            _lhsOisMultiline =
              ( _isMultiline
              )
            _condOforceMultiline =
              ( _lhsIforceMultiline
              )
            _condOindent =
              ( _lhsIindent
              )
            _condOppconf =
              ( _lhsIppconf
              )
            _bodyOcomments =
              ( _condIcomments
              )
            _bodyOforceMultiline =
              ( _lhsIforceMultiline
              )
            _bodyOppconf =
              ( _lhsIppconf
              )
            _elifsOcomments =
              ( _bodyIcomments
              )
            _elifsOforceMultiline =
              ( _lhsIforceMultiline
              )
            _elifsOindent =
              ( _lhsIindent
              )
            _elifsOppconf =
              ( _lhsIppconf
              )
            _elsOcomments =
              ( _elifsIcomments
              )
            _elsOforceMultiline =
              ( _lhsIforceMultiline
              )
            _elsOindent =
              ( _lhsIindent
              )
            _elsOppconf =
              ( _lhsIppconf
              )
            _elsOstatRegion =
              ( _lhsIstatRegion
              )
            (_condIcomments, _condIcopy, _condIendsWithPrefixExpression, _condIisAssociative, _condIisLiteral, _condIisMultiline, _condIpos, _condIprecedence, _condIpretty) =
              cond_ _condOcomments _condOforceMultiline _condOindent _condOparentOperatorAssociative _condOparentOperatorPrecedence _condOppconf
            (_bodyIcomments, _bodyIcopy, _bodyIisMultiline, _bodyIpretty, _bodyIstatementCount) =
              body_ _bodyOcomments _bodyOforceMultiline _bodyOindent _bodyOppconf _bodyOstatRegion
            (_elifsIcomments, _elifsIcopy, _elifsIelsesExist, _elifsIisMultiline, _elifsIpos, _elifsIpretty) =
              elifs_ _elifsOcomments _elifsOforceMultiline _elifsOindent _elifsOppconf
            (_elsIcomments, _elsIcopy, _elsIelsesExist, _elsIisMultiline, _elsIpos, _elsIpretty) =
              els_ _elsOcomments _elsOforceMultiline _elsOindent _elsOppconf _elsOstatRegion
          in
            (_lhsOcomments, _lhsOcopy, _lhsOendsWithPrefixExpression, _lhsOisMultiline, _lhsOpretty, _lhsOstartsWithExprPrefixExpression)
        )
  )
sem_Stat_ANFor
  :: MToken
  -> T_MExpr
  -> T_MExpr
  -> T_MExpr
  -> T_Block
  -> T_Stat
sem_Stat_ANFor var_ val_ to_ step_ body_ =
  ( \_lhsIcomments
     _lhsIforceMultiline
     _lhsIindent
     _lhsIisLastStatement
     _lhsIppconf
     _lhsIstatRegion
     _lhsIwouldBeAmbiguousWithoutSemicolon ->
        ( let
            _lhsOisMultiline :: Bool
            _lhsOstartsWithExprPrefixExpression :: Bool
            _lhsOendsWithPrefixExpression :: Bool
            _lhsOpretty :: Doc
            _valOcomments :: ([MToken])
            _valOparentOperatorPrecedence :: OperatorLevel
            _valOparentOperatorAssociative :: Bool
            _toOparentOperatorPrecedence :: OperatorLevel
            _toOparentOperatorAssociative :: Bool
            _stepOparentOperatorPrecedence :: OperatorLevel
            _stepOparentOperatorAssociative :: Bool
            _bodyOindent :: Int
            _lhsOcopy :: Stat
            _lhsOcomments :: ([MToken])
            _valOforceMultiline :: Bool
            _valOindent :: Int
            _valOppconf :: PrettyPrintConfig
            _toOcomments :: ([MToken])
            _toOforceMultiline :: Bool
            _toOindent :: Int
            _toOppconf :: PrettyPrintConfig
            _stepOcomments :: ([MToken])
            _stepOforceMultiline :: Bool
            _stepOindent :: Int
            _stepOppconf :: PrettyPrintConfig
            _bodyOcomments :: ([MToken])
            _bodyOforceMultiline :: Bool
            _bodyOppconf :: PrettyPrintConfig
            _bodyOstatRegion :: Region
            _valIcomments :: ([MToken])
            _valIcopy :: MExpr
            _valIendsWithPrefixExpression :: Bool
            _valIisAssociative :: Bool
            _valIisLiteral :: Bool
            _valIisMultiline :: Bool
            _valIpos :: Region
            _valIprecedence :: OperatorLevel
            _valIpretty :: Doc
            _toIcomments :: ([MToken])
            _toIcopy :: MExpr
            _toIendsWithPrefixExpression :: Bool
            _toIisAssociative :: Bool
            _toIisLiteral :: Bool
            _toIisMultiline :: Bool
            _toIpos :: Region
            _toIprecedence :: OperatorLevel
            _toIpretty :: Doc
            _stepIcomments :: ([MToken])
            _stepIcopy :: MExpr
            _stepIendsWithPrefixExpression :: Bool
            _stepIisAssociative :: Bool
            _stepIisLiteral :: Bool
            _stepIisMultiline :: Bool
            _stepIpos :: Region
            _stepIprecedence :: OperatorLevel
            _stepIpretty :: Doc
            _bodyIcomments :: ([MToken])
            _bodyIcopy :: Block
            _bodyIisMultiline :: Bool
            _bodyIpretty :: Doc
            _bodyIstatementCount :: Int
            _lhsOisMultiline =
              ( True
              )
            _lhsOstartsWithExprPrefixExpression =
              ( False
              )
            _lhsOendsWithPrefixExpression =
              ( False
              )
            _step =
              ( case _stepIcopy of
                  MExpr _ (ANumber "1") -> empty
                  _ -> _comma <> _stepIpretty
              )
            _lhsOpretty =
              ( zeroWidthText "for"
                  <-> tok var_
                  <-> zchr '='
                  <-> _valIpretty
                  <> _comma
                  <> _toIpretty
                  <> _step
                    <-> zeroWidthText "do"
                    <-> renderSLComments _lhsIppconf _lhsIindent (fst _commentsAfterFor)
                  $+$ _bodyIpretty
                  $+$ indent _lhsIppconf _lhsIindent (zeroWidthText "end")
              )
            _comma =
              ( (if spaceBeforeComma _lhsIppconf then zchr ' ' else empty)
                  <> zchr ','
                  <> (if spaceAfterComma _lhsIppconf then zchr ' ' else empty)
              )
            _commentsAfterFor =
              ( span (\(MToken pos _) -> pos `beforeOrOnLine` mpos var_) _lhsIcomments
              )
            _valOcomments =
              ( snd _commentsAfterFor
              )
            _valOparentOperatorPrecedence =
              ( TopLevelExpression
              )
            _valOparentOperatorAssociative =
              ( True
              )
            _toOparentOperatorPrecedence =
              ( TopLevelExpression
              )
            _toOparentOperatorAssociative =
              ( True
              )
            _stepOparentOperatorPrecedence =
              ( TopLevelExpression
              )
            _stepOparentOperatorAssociative =
              ( True
              )
            _bodyOindent =
              ( _lhsIindent + 1
              )
            _copy =
              ( ANFor var_ _valIcopy _toIcopy _stepIcopy _bodyIcopy
              )
            _lhsOcopy =
              ( _copy
              )
            _lhsOcomments =
              ( _bodyIcomments
              )
            _valOforceMultiline =
              ( _lhsIforceMultiline
              )
            _valOindent =
              ( _lhsIindent
              )
            _valOppconf =
              ( _lhsIppconf
              )
            _toOcomments =
              ( _valIcomments
              )
            _toOforceMultiline =
              ( _lhsIforceMultiline
              )
            _toOindent =
              ( _lhsIindent
              )
            _toOppconf =
              ( _lhsIppconf
              )
            _stepOcomments =
              ( _toIcomments
              )
            _stepOforceMultiline =
              ( _lhsIforceMultiline
              )
            _stepOindent =
              ( _lhsIindent
              )
            _stepOppconf =
              ( _lhsIppconf
              )
            _bodyOcomments =
              ( _stepIcomments
              )
            _bodyOforceMultiline =
              ( _lhsIforceMultiline
              )
            _bodyOppconf =
              ( _lhsIppconf
              )
            _bodyOstatRegion =
              ( _lhsIstatRegion
              )
            (_valIcomments, _valIcopy, _valIendsWithPrefixExpression, _valIisAssociative, _valIisLiteral, _valIisMultiline, _valIpos, _valIprecedence, _valIpretty) =
              val_ _valOcomments _valOforceMultiline _valOindent _valOparentOperatorAssociative _valOparentOperatorPrecedence _valOppconf
            (_toIcomments, _toIcopy, _toIendsWithPrefixExpression, _toIisAssociative, _toIisLiteral, _toIisMultiline, _toIpos, _toIprecedence, _toIpretty) =
              to_ _toOcomments _toOforceMultiline _toOindent _toOparentOperatorAssociative _toOparentOperatorPrecedence _toOppconf
            (_stepIcomments, _stepIcopy, _stepIendsWithPrefixExpression, _stepIisAssociative, _stepIisLiteral, _stepIisMultiline, _stepIpos, _stepIprecedence, _stepIpretty) =
              step_ _stepOcomments _stepOforceMultiline _stepOindent _stepOparentOperatorAssociative _stepOparentOperatorPrecedence _stepOppconf
            (_bodyIcomments, _bodyIcopy, _bodyIisMultiline, _bodyIpretty, _bodyIstatementCount) =
              body_ _bodyOcomments _bodyOforceMultiline _bodyOindent _bodyOppconf _bodyOstatRegion
          in
            (_lhsOcomments, _lhsOcopy, _lhsOendsWithPrefixExpression, _lhsOisMultiline, _lhsOpretty, _lhsOstartsWithExprPrefixExpression)
        )
  )
sem_Stat_AGFor
  :: ([MToken])
  -> T_MExprList
  -> T_Block
  -> T_Stat
sem_Stat_AGFor vars_ vals_ body_ =
  ( \_lhsIcomments
     _lhsIforceMultiline
     _lhsIindent
     _lhsIisLastStatement
     _lhsIppconf
     _lhsIstatRegion
     _lhsIwouldBeAmbiguousWithoutSemicolon ->
        ( let
            _lhsOisMultiline :: Bool
            _lhsOstartsWithExprPrefixExpression :: Bool
            _lhsOendsWithPrefixExpression :: Bool
            _lhsOpretty :: Doc
            _bodyOindent :: Int
            _valsOcomments :: ([MToken])
            _valsOforceMultiline :: Bool
            _valsOsomeElementsInListAreMultiline :: Bool
            _lhsOcopy :: Stat
            _lhsOcomments :: ([MToken])
            _valsOindent :: Int
            _valsOppconf :: PrettyPrintConfig
            _bodyOcomments :: ([MToken])
            _bodyOforceMultiline :: Bool
            _bodyOppconf :: PrettyPrintConfig
            _bodyOstatRegion :: Region
            _valsIcomments :: ([MToken])
            _valsIcopy :: MExprList
            _valsIisAssociative :: Bool
            _valsIisLast :: Bool
            _valsIisMultiline :: Bool
            _valsIpos :: Region
            _valsIprecedence :: OperatorLevel
            _valsIpretty :: Doc
            _bodyIcomments :: ([MToken])
            _bodyIcopy :: Block
            _bodyIisMultiline :: Bool
            _bodyIpretty :: Doc
            _bodyIstatementCount :: Int
            _lhsOisMultiline =
              ( True
              )
            _lhsOstartsWithExprPrefixExpression =
              ( False
              )
            _lhsOendsWithPrefixExpression =
              ( False
              )
            _lhsOpretty =
              ( zeroWidthText "for"
                  <-> printList tok (render _comma) vars_
                  <-> zeroWidthText "in"
                  <-> _valsIpretty
                  <-> zeroWidthText "do"
                  <-> renderSLComments _lhsIppconf _lhsIindent (fst _commentsAfterFor)
                  $+$ _bodyIpretty
                  $+$ indent _lhsIppconf _lhsIindent (zeroWidthText "end")
              )
            _bodyOindent =
              ( _lhsIindent + 1
              )
            _comma =
              ( (if spaceBeforeComma _lhsIppconf then zchr ' ' else empty)
                  <> zchr ','
                  <> (if spaceAfterComma _lhsIppconf then zchr ' ' else empty)
              )
            _commentsAfterFor =
              ( span (\(MToken pos _) -> pos `beforeOrOnLine` mpos (head vars_)) _lhsIcomments
              )
            _valsOcomments =
              ( snd _commentsAfterFor
              )
            _valsOforceMultiline =
              ( False
              )
            _valsOsomeElementsInListAreMultiline =
              ( False
              )
            _copy =
              ( AGFor vars_ _valsIcopy _bodyIcopy
              )
            _lhsOcopy =
              ( _copy
              )
            _lhsOcomments =
              ( _bodyIcomments
              )
            _valsOindent =
              ( _lhsIindent
              )
            _valsOppconf =
              ( _lhsIppconf
              )
            _bodyOcomments =
              ( _valsIcomments
              )
            _bodyOforceMultiline =
              ( _lhsIforceMultiline
              )
            _bodyOppconf =
              ( _lhsIppconf
              )
            _bodyOstatRegion =
              ( _lhsIstatRegion
              )
            (_valsIcomments, _valsIcopy, _valsIisAssociative, _valsIisLast, _valsIisMultiline, _valsIpos, _valsIprecedence, _valsIpretty) =
              vals_ _valsOcomments _valsOforceMultiline _valsOindent _valsOppconf _valsOsomeElementsInListAreMultiline
            (_bodyIcomments, _bodyIcopy, _bodyIisMultiline, _bodyIpretty, _bodyIstatementCount) =
              body_ _bodyOcomments _bodyOforceMultiline _bodyOindent _bodyOppconf _bodyOstatRegion
          in
            (_lhsOcomments, _lhsOcopy, _lhsOendsWithPrefixExpression, _lhsOisMultiline, _lhsOpretty, _lhsOstartsWithExprPrefixExpression)
        )
  )
sem_Stat_AFunc
  :: T_FuncName
  -> ([MToken])
  -> T_Block
  -> T_Stat
sem_Stat_AFunc name_ args_ body_ =
  ( \_lhsIcomments
     _lhsIforceMultiline
     _lhsIindent
     _lhsIisLastStatement
     _lhsIppconf
     _lhsIstatRegion
     _lhsIwouldBeAmbiguousWithoutSemicolon ->
        ( let
            _lhsOisMultiline :: Bool
            _lhsOstartsWithExprPrefixExpression :: Bool
            _lhsOendsWithPrefixExpression :: Bool
            _lhsOpretty :: Doc
            _nameOcomments :: ([MToken])
            _bodyOindent :: Int
            _lhsOcopy :: Stat
            _lhsOcomments :: ([MToken])
            _nameOindent :: Int
            _nameOppconf :: PrettyPrintConfig
            _bodyOcomments :: ([MToken])
            _bodyOforceMultiline :: Bool
            _bodyOppconf :: PrettyPrintConfig
            _bodyOstatRegion :: Region
            _nameIcomments :: ([MToken])
            _nameIcopy :: FuncName
            _nameIisMultiline :: Bool
            _nameIpos :: Region
            _nameIpretty :: Doc
            _bodyIcomments :: ([MToken])
            _bodyIcopy :: Block
            _bodyIisMultiline :: Bool
            _bodyIpretty :: Doc
            _bodyIstatementCount :: Int
            _lhsOisMultiline =
              ( True
              )
            _lhsOstartsWithExprPrefixExpression =
              ( False
              )
            _lhsOendsWithPrefixExpression =
              ( False
              )
            _lhsOpretty =
              ( zeroWidthText "function"
                  <-> _nameIpretty
                  <> parens _lhsIppconf _emptyParams (printList tok (render _comma) args_)
                    <-> renderSLComments _lhsIppconf _lhsIindent (fst _commentsAfterFunc)
                  $+$ _bodyIpretty
                  $+$ indent _lhsIppconf _lhsIindent (zeroWidthText "end")
              )
            _commentsAfterFunc =
              ( span (\(MToken pos _) -> pos `beforeOrOnLine` _nameIpos) _lhsIcomments
              )
            _nameOcomments =
              ( snd _commentsAfterFunc
              )
            _emptyParams =
              ( toEmpty $ null args_
              )
            _comma =
              ( (if spaceBeforeComma _lhsIppconf then zchr ' ' else empty)
                  <> zchr ','
                  <> (if spaceAfterComma _lhsIppconf then zchr ' ' else empty)
              )
            _bodyOindent =
              ( _lhsIindent + 1
              )
            _copy =
              ( AFunc _nameIcopy args_ _bodyIcopy
              )
            _lhsOcopy =
              ( _copy
              )
            _lhsOcomments =
              ( _bodyIcomments
              )
            _nameOindent =
              ( _lhsIindent
              )
            _nameOppconf =
              ( _lhsIppconf
              )
            _bodyOcomments =
              ( _nameIcomments
              )
            _bodyOforceMultiline =
              ( _lhsIforceMultiline
              )
            _bodyOppconf =
              ( _lhsIppconf
              )
            _bodyOstatRegion =
              ( _lhsIstatRegion
              )
            (_nameIcomments, _nameIcopy, _nameIisMultiline, _nameIpos, _nameIpretty) =
              name_ _nameOcomments _nameOindent _nameOppconf
            (_bodyIcomments, _bodyIcopy, _bodyIisMultiline, _bodyIpretty, _bodyIstatementCount) =
              body_ _bodyOcomments _bodyOforceMultiline _bodyOindent _bodyOppconf _bodyOstatRegion
          in
            (_lhsOcomments, _lhsOcopy, _lhsOendsWithPrefixExpression, _lhsOisMultiline, _lhsOpretty, _lhsOstartsWithExprPrefixExpression)
        )
  )
sem_Stat_ALocFunc
  :: T_FuncName
  -> ([MToken])
  -> T_Block
  -> T_Stat
sem_Stat_ALocFunc name_ args_ body_ =
  ( \_lhsIcomments
     _lhsIforceMultiline
     _lhsIindent
     _lhsIisLastStatement
     _lhsIppconf
     _lhsIstatRegion
     _lhsIwouldBeAmbiguousWithoutSemicolon ->
        ( let
            _lhsOisMultiline :: Bool
            _lhsOpretty :: Doc
            _lhsOstartsWithExprPrefixExpression :: Bool
            _lhsOendsWithPrefixExpression :: Bool
            _nameOcomments :: ([MToken])
            _bodyOindent :: Int
            _lhsOcopy :: Stat
            _lhsOcomments :: ([MToken])
            _nameOindent :: Int
            _nameOppconf :: PrettyPrintConfig
            _bodyOcomments :: ([MToken])
            _bodyOforceMultiline :: Bool
            _bodyOppconf :: PrettyPrintConfig
            _bodyOstatRegion :: Region
            _nameIcomments :: ([MToken])
            _nameIcopy :: FuncName
            _nameIisMultiline :: Bool
            _nameIpos :: Region
            _nameIpretty :: Doc
            _bodyIcomments :: ([MToken])
            _bodyIcopy :: Block
            _bodyIisMultiline :: Bool
            _bodyIpretty :: Doc
            _bodyIstatementCount :: Int
            _lhsOisMultiline =
              ( True
              )
            _lhsOpretty =
              ( zeroWidthText "local function"
                  <-> _nameIpretty
                  <> parens _lhsIppconf _emptyParams (printList tok (render _comma) args_)
                    <-> renderSLComments _lhsIppconf _lhsIindent (fst _commentsAfterFunc)
                  $+$ _bodyIpretty
                  $+$ indent _lhsIppconf _lhsIindent (zeroWidthText "end")
              )
            _lhsOstartsWithExprPrefixExpression =
              ( False
              )
            _lhsOendsWithPrefixExpression =
              ( False
              )
            _commentsAfterFunc =
              ( span (\(MToken pos _) -> pos `beforeOrOnLine` _nameIpos) _lhsIcomments
              )
            _nameOcomments =
              ( snd _commentsAfterFunc
              )
            _emptyParams =
              ( toEmpty $ null args_
              )
            _comma =
              ( (if spaceBeforeComma _lhsIppconf then zchr ' ' else empty)
                  <> zchr ','
                  <> (if spaceAfterComma _lhsIppconf then zchr ' ' else empty)
              )
            _bodyOindent =
              ( _lhsIindent + 1
              )
            _copy =
              ( ALocFunc _nameIcopy args_ _bodyIcopy
              )
            _lhsOcopy =
              ( _copy
              )
            _lhsOcomments =
              ( _bodyIcomments
              )
            _nameOindent =
              ( _lhsIindent
              )
            _nameOppconf =
              ( _lhsIppconf
              )
            _bodyOcomments =
              ( _nameIcomments
              )
            _bodyOforceMultiline =
              ( _lhsIforceMultiline
              )
            _bodyOppconf =
              ( _lhsIppconf
              )
            _bodyOstatRegion =
              ( _lhsIstatRegion
              )
            (_nameIcomments, _nameIcopy, _nameIisMultiline, _nameIpos, _nameIpretty) =
              name_ _nameOcomments _nameOindent _nameOppconf
            (_bodyIcomments, _bodyIcopy, _bodyIisMultiline, _bodyIpretty, _bodyIstatementCount) =
              body_ _bodyOcomments _bodyOforceMultiline _bodyOindent _bodyOppconf _bodyOstatRegion
          in
            (_lhsOcomments, _lhsOcopy, _lhsOendsWithPrefixExpression, _lhsOisMultiline, _lhsOpretty, _lhsOstartsWithExprPrefixExpression)
        )
  )

-- UnOp --------------------------------------------------------
-- cata
sem_UnOp
  :: UnOp
  -> T_UnOp
sem_UnOp (UnMinus) =
  (sem_UnOp_UnMinus)
sem_UnOp (ANot) =
  (sem_UnOp_ANot)
sem_UnOp (AHash) =
  (sem_UnOp_AHash)

-- semantic domain
type T_UnOp =
  ([MToken])
  -> Int
  -> PrettyPrintConfig
  -> (([MToken]), UnOp, Bool, Doc)
data Inh_UnOp = Inh_UnOp {comments_Inh_UnOp :: ([MToken]), indent_Inh_UnOp :: Int, ppconf_Inh_UnOp :: PrettyPrintConfig}
data Syn_UnOp = Syn_UnOp {comments_Syn_UnOp :: ([MToken]), copy_Syn_UnOp :: UnOp, isMultiline_Syn_UnOp :: Bool, pretty_Syn_UnOp :: Doc}
wrap_UnOp
  :: T_UnOp
  -> Inh_UnOp
  -> Syn_UnOp
wrap_UnOp sem (Inh_UnOp _lhsIcomments _lhsIindent _lhsIppconf) =
  ( let
      (_lhsOcomments, _lhsOcopy, _lhsOisMultiline, _lhsOpretty) = sem _lhsIcomments _lhsIindent _lhsIppconf
    in
      (Syn_UnOp _lhsOcomments _lhsOcopy _lhsOisMultiline _lhsOpretty)
  )
sem_UnOp_UnMinus :: T_UnOp
sem_UnOp_UnMinus =
  ( \_lhsIcomments
     _lhsIindent
     _lhsIppconf ->
        ( let
            _lhsOpretty :: Doc
            _lhsOisMultiline :: Bool
            _lhsOcopy :: UnOp
            _lhsOcomments :: ([MToken])
            _lhsOpretty =
              ( zeroWidthText "-"
              )
            _lhsOisMultiline =
              ( False
              )
            _copy =
              ( UnMinus
              )
            _lhsOcopy =
              ( _copy
              )
            _lhsOcomments =
              ( _lhsIcomments
              )
          in
            (_lhsOcomments, _lhsOcopy, _lhsOisMultiline, _lhsOpretty)
        )
  )
sem_UnOp_ANot :: T_UnOp
sem_UnOp_ANot =
  ( \_lhsIcomments
     _lhsIindent
     _lhsIppconf ->
        ( let
            _lhsOpretty :: Doc
            _lhsOisMultiline :: Bool
            _lhsOcopy :: UnOp
            _lhsOcomments :: ([MToken])
            _lhsOpretty =
              ( zeroWidthText (if cStyle _lhsIppconf then "!" else "not ")
              )
            _lhsOisMultiline =
              ( False
              )
            _copy =
              ( ANot
              )
            _lhsOcopy =
              ( _copy
              )
            _lhsOcomments =
              ( _lhsIcomments
              )
          in
            (_lhsOcomments, _lhsOcopy, _lhsOisMultiline, _lhsOpretty)
        )
  )
sem_UnOp_AHash :: T_UnOp
sem_UnOp_AHash =
  ( \_lhsIcomments
     _lhsIindent
     _lhsIppconf ->
        ( let
            _lhsOpretty :: Doc
            _lhsOisMultiline :: Bool
            _lhsOcopy :: UnOp
            _lhsOcomments :: ([MToken])
            _lhsOpretty =
              ( zeroWidthText "#"
              )
            _lhsOisMultiline =
              ( False
              )
            _copy =
              ( AHash
              )
            _lhsOcopy =
              ( _copy
              )
            _lhsOcomments =
              ( _lhsIcomments
              )
          in
            (_lhsOcomments, _lhsOcopy, _lhsOisMultiline, _lhsOpretty)
        )
  )

-- VarsList ----------------------------------------------------
-- cata
sem_VarsList
  :: VarsList
  -> T_VarsList
sem_VarsList list =
  (Prelude.foldr sem_VarsList_Cons sem_VarsList_Nil (Prelude.map sem_Declaration list))

-- semantic domain
type T_VarsList =
  ([MToken])
  -> Bool
  -> Int
  -> PrettyPrintConfig
  -> (([MToken]), VarsList, Bool, Doc, Bool, Bool, Bool, Doc, Bool, Doc)
data Inh_VarsList = Inh_VarsList {comments_Inh_VarsList :: ([MToken]), forceMultiline_Inh_VarsList :: Bool, indent_Inh_VarsList :: Int, ppconf_Inh_VarsList :: PrettyPrintConfig}
data Syn_VarsList = Syn_VarsList {comments_Syn_VarsList :: ([MToken]), copy_Syn_VarsList :: VarsList, endsWithPrefixExpression_Syn_VarsList :: Bool, exprPretty_Syn_VarsList :: Doc, isDefined_Syn_VarsList :: Bool, isLast_Syn_VarsList :: Bool, isMultiline_Syn_VarsList :: Bool, pretty_Syn_VarsList :: Doc, startsWithExprPrefixExpression_Syn_VarsList :: Bool, varPretty_Syn_VarsList :: Doc}
wrap_VarsList
  :: T_VarsList
  -> Inh_VarsList
  -> Syn_VarsList
wrap_VarsList sem (Inh_VarsList _lhsIcomments _lhsIforceMultiline _lhsIindent _lhsIppconf) =
  ( let
      (_lhsOcomments, _lhsOcopy, _lhsOendsWithPrefixExpression, _lhsOexprPretty, _lhsOisDefined, _lhsOisLast, _lhsOisMultiline, _lhsOpretty, _lhsOstartsWithExprPrefixExpression, _lhsOvarPretty) = sem _lhsIcomments _lhsIforceMultiline _lhsIindent _lhsIppconf
    in
      (Syn_VarsList _lhsOcomments _lhsOcopy _lhsOendsWithPrefixExpression _lhsOexprPretty _lhsOisDefined _lhsOisLast _lhsOisMultiline _lhsOpretty _lhsOstartsWithExprPrefixExpression _lhsOvarPretty)
  )
sem_VarsList_Cons
  :: T_Declaration
  -> T_VarsList
  -> T_VarsList
sem_VarsList_Cons hd_ tl_ =
  ( \_lhsIcomments
     _lhsIforceMultiline
     _lhsIindent
     _lhsIppconf ->
        ( let
            _lhsOpretty :: Doc
            _lhsOstartsWithExprPrefixExpression :: Bool
            _lhsOendsWithPrefixExpression :: Bool
            _lhsOisMultiline :: Bool
            _lhsOisLast :: Bool
            _lhsOexprPretty :: Doc
            _lhsOisDefined :: Bool
            _lhsOvarPretty :: Doc
            _lhsOcopy :: VarsList
            _lhsOcomments :: ([MToken])
            _hdOcomments :: ([MToken])
            _hdOforceMultiline :: Bool
            _hdOindent :: Int
            _hdOppconf :: PrettyPrintConfig
            _tlOcomments :: ([MToken])
            _tlOforceMultiline :: Bool
            _tlOindent :: Int
            _tlOppconf :: PrettyPrintConfig
            _hdIcomments :: ([MToken])
            _hdIcopy :: Declaration
            _hdIendsWithPrefixExpression :: Bool
            _hdIexprPretty :: Doc
            _hdIisDefined :: Bool
            _hdIisMultiline :: Bool
            _hdIpretty :: Doc
            _hdIstartsWithExprPrefixExpression :: Bool
            _hdIvarPretty :: Doc
            _tlIcomments :: ([MToken])
            _tlIcopy :: VarsList
            _tlIendsWithPrefixExpression :: Bool
            _tlIexprPretty :: Doc
            _tlIisDefined :: Bool
            _tlIisLast :: Bool
            _tlIisMultiline :: Bool
            _tlIpretty :: Doc
            _tlIstartsWithExprPrefixExpression :: Bool
            _tlIvarPretty :: Doc
            _lhsOpretty =
              ( _varPretty
                  <-> if _isDefined then zchr '=' <-> _exprPretty else empty
              )
            _lhsOstartsWithExprPrefixExpression =
              ( _hdIstartsWithExprPrefixExpression
              )
            _lhsOendsWithPrefixExpression =
              ( if _tlIisDefined then _tlIendsWithPrefixExpression else _hdIendsWithPrefixExpression
              )
            _lhsOisMultiline =
              ( _hdIisMultiline || _tlIisMultiline
              )
            _isDefined =
              ( _hdIisDefined || _tlIisDefined
              )
            _varPretty =
              ( _hdIvarPretty
                  <> (if _tlIisLast then empty else _comma)
                  <> _tlIvarPretty
              )
            _exprPretty =
              ( _hdIexprPretty
                  <> (if not _tlIisLast && _tlIisDefined then _comma else empty)
                  <> _tlIexprPretty
              )
            _comma =
              ( (if spaceBeforeComma _lhsIppconf then zchr ' ' else empty)
                  <> zchr ','
                  <> (if spaceAfterComma _lhsIppconf then zchr ' ' else empty)
              )
            _lhsOisLast =
              ( False
              )
            _lhsOexprPretty =
              ( _exprPretty
              )
            _lhsOisDefined =
              ( _isDefined
              )
            _lhsOvarPretty =
              ( _varPretty
              )
            _copy =
              ( (:) _hdIcopy _tlIcopy
              )
            _lhsOcopy =
              ( _copy
              )
            _lhsOcomments =
              ( _tlIcomments
              )
            _hdOcomments =
              ( _lhsIcomments
              )
            _hdOforceMultiline =
              ( _lhsIforceMultiline
              )
            _hdOindent =
              ( _lhsIindent
              )
            _hdOppconf =
              ( _lhsIppconf
              )
            _tlOcomments =
              ( _hdIcomments
              )
            _tlOforceMultiline =
              ( _lhsIforceMultiline
              )
            _tlOindent =
              ( _lhsIindent
              )
            _tlOppconf =
              ( _lhsIppconf
              )
            (_hdIcomments, _hdIcopy, _hdIendsWithPrefixExpression, _hdIexprPretty, _hdIisDefined, _hdIisMultiline, _hdIpretty, _hdIstartsWithExprPrefixExpression, _hdIvarPretty) =
              hd_ _hdOcomments _hdOforceMultiline _hdOindent _hdOppconf
            (_tlIcomments, _tlIcopy, _tlIendsWithPrefixExpression, _tlIexprPretty, _tlIisDefined, _tlIisLast, _tlIisMultiline, _tlIpretty, _tlIstartsWithExprPrefixExpression, _tlIvarPretty) =
              tl_ _tlOcomments _tlOforceMultiline _tlOindent _tlOppconf
          in
            (_lhsOcomments, _lhsOcopy, _lhsOendsWithPrefixExpression, _lhsOexprPretty, _lhsOisDefined, _lhsOisLast, _lhsOisMultiline, _lhsOpretty, _lhsOstartsWithExprPrefixExpression, _lhsOvarPretty)
        )
  )
sem_VarsList_Nil :: T_VarsList
sem_VarsList_Nil =
  ( \_lhsIcomments
     _lhsIforceMultiline
     _lhsIindent
     _lhsIppconf ->
        ( let
            _lhsOpretty :: Doc
            _lhsOstartsWithExprPrefixExpression :: Bool
            _lhsOendsWithPrefixExpression :: Bool
            _lhsOisMultiline :: Bool
            _lhsOisLast :: Bool
            _lhsOexprPretty :: Doc
            _lhsOisDefined :: Bool
            _lhsOvarPretty :: Doc
            _lhsOcopy :: VarsList
            _lhsOcomments :: ([MToken])
            _lhsOpretty =
              ( empty
              )
            _lhsOstartsWithExprPrefixExpression =
              ( False
              )
            _lhsOendsWithPrefixExpression =
              ( False
              )
            _lhsOisMultiline =
              ( False
              )
            _lhsOisLast =
              ( True
              )
            _lhsOexprPretty =
              ( empty
              )
            _lhsOisDefined =
              ( False
              )
            _lhsOvarPretty =
              ( empty
              )
            _copy =
              ( []
              )
            _lhsOcopy =
              ( _copy
              )
            _lhsOcomments =
              ( _lhsIcomments
              )
          in
            (_lhsOcomments, _lhsOcopy, _lhsOendsWithPrefixExpression, _lhsOexprPretty, _lhsOisDefined, _lhsOisLast, _lhsOisMultiline, _lhsOpretty, _lhsOstartsWithExprPrefixExpression, _lhsOvarPretty)
        )
  )