packages feed

uhc-light-1.1.9.2: src/UHC/Light/Compiler/EH/MainAG_Decls.hs



module UHC.Light.Compiler.EH.MainAG_Decls where

import Data.Char
import Data.List as List
import UHC.Util.Pretty
import UHC.Light.Compiler.Base.Common
import UHC.Light.Compiler.Base.TermLike
import UHC.Light.Compiler.Base.HsName.Builtin
import UHC.Light.Compiler.Opts
import UHC.Light.Compiler.Gam.Full
import UHC.Light.Compiler.Error
import UHC.Light.Compiler.Error.Pretty
import UHC.Light.Compiler.EH
import UHC.Light.Compiler.Ty.Pretty
import UHC.Light.Compiler.Ty.FitsInCommon
import UHC.Light.Compiler.Ty.FitsIn
import qualified UHC.Util.FastSeq as Seq
import UHC.Util.Utils
import UHC.Light.Compiler.Base.Trace
import UHC.Light.Compiler.Base.UnderDev
import UHC.Light.Compiler.VarMp
import UHC.Light.Compiler.Substitutable
import Data.Maybe
import UHC.Light.Compiler.Ty.Utils1
import UHC.Light.Compiler.Ty.Trf.Quantify
import UHC.Light.Compiler.Ty.Trf.Instantiate
import UHC.Light.Compiler.Ty
import UHC.Light.Compiler.Ty.FitsInCommon2
import UHC.Light.Compiler.Ty.FIEnv2
import qualified Data.Set as Set
import qualified Data.Map as Map
import Data.Set (Set)
import Data.Map (Map)
import UHC.Light.Compiler.Ty.Trf.FreshVar
import UHC.Light.Compiler.Ty.Ftv
import UHC.Util.Utils (groupSortOn)
import Control.Applicative ((<|>))
import UHC.Light.Compiler.AbstractCore
import UHC.Light.Compiler.AbstractCore.Utils
import UHC.Light.Compiler.Core
import UHC.Light.Compiler.Core.FFI
import UHC.Light.Compiler.Core.Utils
import UHC.Light.Compiler.Core.Pretty
import UHC.Light.Compiler.Foreign.Extract
import UHC.Light.Compiler.LamInfo
import UHC.Light.Compiler.CodeGen.RefGenerator
import qualified UHC.Light.Compiler.Core.SysF.AsTy as SysF
import UHC.Light.Compiler.FinalEnv
import UHC.Light.Compiler.Core.BindExtract
import UHC.Light.Compiler.Core.Subst
import Control.Monad.State
import UHC.Light.Compiler.Ty.Utils2
import UHC.Light.Compiler.Base.Target
import UHC.Light.Compiler.Core.Coercion
import UHC.Light.Compiler.Ty.Trf.MergePreds
import UHC.Light.Compiler.Ty.Trf.Canonic
import UHC.Light.Compiler.Gam.ClGam
import UHC.Light.Compiler.Pred
import UHC.Light.Compiler.Pred.RedGraph (redPruneReductionsUntil)
import UHC.Util.CHR
import UHC.Light.Compiler.CHR.Constraint
import UHC.Light.Compiler.CHR.Guard
import UHC.Light.Compiler.Pred.ToCHR
import UHC.Light.Compiler.Pred.Heuristics
import UHC.Light.Compiler.Pred.Evidence
import UHC.Light.Compiler.CHR.Solve
import UHC.Light.Compiler.Pred.EvidenceToCore
import UHC.Light.Compiler.Gam.ClassDefaultGam
import UHC.Light.Compiler.Ty.Trf.BetaReduce (tyBetaRedFull)
import UHC.Light.Compiler.Module.ImportExport
import UHC.Light.Compiler.Ty.UsedNames
import UHC.Light.Compiler.CodeGen.ImportUsedModules
import UHC.Light.Compiler.CodeGen.ModuleImportExportImpl
import UHC.Light.Compiler.CodeGen.BuiltinPrims
import UHC.Light.Compiler.Foreign
import UHC.Light.Compiler.Foreign
import UHC.Light.Compiler.Foreign.Pretty
import UHC.Light.Compiler.Deriving
import UHC.Light.Compiler.Generics
import UHC.Light.Compiler.VarMp.Utils

import UHC.Light.Compiler.EH.MainAG_common

-- Decls -------------------------------------------------------
{-
   visit 0:
      synthesized attribute:
         range                : Range
   visit 1:
      chained attributes:
         gUniq                : UID
         gathKiSigGam         : TyGam
      synthesized attribute:
         hasInstDecl          : Bool
   visit 2:
      inherited attribute:
         kiGam                : KiGam
      synthesized attribute:
         gathTyKiSigGam       : TyKiGam
   visit 3:
      inherited attribute:
         lexLev               : Int
      chained attribute:
         predSameScopeCounter : Int
   visit 4:
      inherited attribute:
         tyKiSigGam           : TyKiGam
      chained attribute:
         patTyGam             : TyGam
   visit 5:
      inherited attribute:
         tyGam                : TyGam
      chained attributes:
         patTyKiGam           : TyKiGam
         tyTyVarMp            : VarMp
   visit 6:
      inherited attribute:
         tyKiGam              : TyKiGam
      chained attributes:
         patKiVarMp           : VarMp
         patPolGam            : PolGam
   visit 7:
      inherited attributes:
         mbKnPolCtx           : Maybe Polarity
         opts                 : EHCOpts
         polGam               : PolGam
         predScope            : PredScope
         tyKiGlobFreeTvarS    : TyVarIdS
      chained attributes:
         generDataInfoMp      : GenerDataInfoMp
         kiVarMp              : VarMp
         polVarMp             : VarMp
      synthesized attribute:
         generDataInfoL       : [GenerDataInfo]
   visit 8:
      chained attribute:
         patClGam1            : ClGam
   visit 9:
      inherited attributes:
         finKiVarMp           : VarMp
         finTyKiGam           : TyKiGam
         tyTyTySigFreeTvarS   : TyVarIdS
      chained attribute:
         patClGam2            : ClGam
   visit 10:
      inherited attribute:
         clGam                : ClGam
      chained attribute:
         gathDataGam          : DataGam
      synthesized attributes:
         gathDeclDataGam      : DataGam
         gathTySigGam         : ValGam
         gathTySigVarMp       : VarMp
   visit 11:
      inherited attribute:
         dataGam              : DataGam
      synthesized attributes:
         chrClassDeclSq       : Seq.FastSeq (CHRClassDecl)
         chrInstDeclSq        : Seq.FastSeq (CHRScopedInstanceDecl)
         gathClDfGam          : ClassDefaultGam
   visit 12:
      inherited attributes:
         tvKiVarMp            : VarMp
         tySigGam             : ValGam
         tySigVarMp           : VarMp
      chained attributes:
         patTyVarMp           : VarMp
         patValGam            : ValGam
   visit 13:
      inherited attributes:
         chrStore             : CHRStore
         clDfGam              : ClassDefaultGam
         tyTyGlobFreeTvarS    : TyVarIdS
         valGam               : ValGam
         valTyGlobFreeTvarS   : TyVarIdS
      chained attribute:
         tyVarMp              : VarMp
      synthesized attributes:
         gathCnstrMp          : ConstraintToInfoMap
         gathRangeMp          : RangeMp
         intlTyKiGam          : TyKiGam
         noLetQuantTyVarIdS   : TyVarIdS
         scopeGam             : ScopeGam
   visit 14:
      inherited attributes:
         chrEvidBindMp        : EvidKeyToCBindMap
         chrScopeBindMp       : PredScopeToCBindMap
         finTyVarMp           : VarMp
         finValGam            : ValGam
         isStrict             : Bool
         kiSigGam             : TyGam
         moduleNm             : HsName
         rangeMp              : RangeMp
         sysfEnv              : ToSysfEnv
         tr                   : TraceOn -> [PP_Doc] -> TrPP
      chained attribute:
         cSubst               : CSubst
      synthesized attributes:
         allErrSq             : ErrSq
         bangEvalL            : [CExpr -> CExpr]
         errSq                : ErrSq
         ffeCBindL            : CBindL
         ffiCBindL            : CBindL
         gathHiddenExports    : Seq.Seq (HsName,IdOccKind)
         gathLamMp            : LamMp
         gathMentrelFilterMp  : ModEntRelFilterMp
         gathTvKiVarMp        : VarMp
         orphanS              : Set.Set HsName
         pp                   : PP_Doc
         ppAST                : PP_Doc
         trpp                 : TrPP
         tyCBindL             : CBindL
         valCBindL            : CBindL
   alternatives:
      alternative Cons:
         child hd             : Decl 
         child tl             : Decls 
         visit 14:
            local errPP       : _
            local trppHere    : _
      alternative Nil:
         visit 14:
            local trppHere    : _
-}
sem_Decls_Cons :: T_Decl ->
                  T_Decls ->
                  T_Decls

sem_Decls_Cons hd_ tl_ | hd_ `seq` (tl_ `seq` (True)) =
    (case (tl_) of
     { ( _tlIrange,tl_1) | True ->
         (case (hd_) of
          { ( _hdIrange,hd_1) | True ->
              (case (_hdIrange `rangeUnion` _tlIrange) of
               { _lhsOrange | _lhsOrange `seq` (True) ->
               (case ((let sem_Decls_Cons_1 :: T_Decls_1
                           sem_Decls_Cons_1 =
                               (\ _lhsIgUniq
                                  _lhsIgathKiSigGam ->
                                    _lhsIgUniq `seq`
                                    (_lhsIgathKiSigGam `seq`
                                     ((case (_lhsIgUniq) of
                                       { _hdOgUniq | _hdOgUniq `seq` (True) ->
                                       (case (_lhsIgathKiSigGam) of
                                        { _hdOgathKiSigGam | _hdOgathKiSigGam `seq` (True) ->
                                        (case (hd_1 _hdOgUniq _hdOgathKiSigGam) of
                                         { ( _hdIgUniq,_hdIgathKiSigGam,_hdIhasInstDecl,hd_2) | True ->
                                             (case (_hdIgUniq) of
                                              { _tlOgUniq | _tlOgUniq `seq` (True) ->
                                              (case (_hdIgathKiSigGam) of
                                               { _tlOgathKiSigGam | _tlOgathKiSigGam `seq` (True) ->
                                               (case (tl_1 _tlOgUniq _tlOgathKiSigGam) of
                                                { ( _tlIgUniq,_tlIgathKiSigGam,_tlIhasInstDecl,tl_2) | True ->
                                                    (case (_tlIgUniq) of
                                                     { _lhsOgUniq | _lhsOgUniq `seq` (True) ->
                                                     (case (_tlIgathKiSigGam) of
                                                      { _lhsOgathKiSigGam | _lhsOgathKiSigGam `seq` (True) ->
                                                      (case (_hdIhasInstDecl || _tlIhasInstDecl) of
                                                       { _lhsOhasInstDecl | _lhsOhasInstDecl `seq` (True) ->
                                                       (case ((let sem_Decls_Cons_2 :: T_Decls_2
                                                                   sem_Decls_Cons_2 =
                                                                       (\ _lhsIkiGam ->
                                                                            _lhsIkiGam `seq`
                                                                            ((case (_lhsIkiGam) of
                                                                              { _tlOkiGam | _tlOkiGam `seq` (True) ->
                                                                              (case (_lhsIkiGam) of
                                                                               { _hdOkiGam | _hdOkiGam `seq` (True) ->
                                                                               (case (tl_2 _tlOkiGam) of
                                                                                { ( _tlIgathTyKiSigGam,tl_3) | True ->
                                                                                    (case (hd_2 _hdOkiGam) of
                                                                                     { ( _hdIgathTyKiSigGam,hd_3) | True ->
                                                                                         (case (_hdIgathTyKiSigGam `gamUnion` _tlIgathTyKiSigGam) of
                                                                                          { _lhsOgathTyKiSigGam | _lhsOgathTyKiSigGam `seq` (True) ->
                                                                                          (case ((let sem_Decls_Cons_3 :: T_Decls_3
                                                                                                      sem_Decls_Cons_3 =
                                                                                                          (\ _lhsIlexLev
                                                                                                             _lhsIpredSameScopeCounter ->
                                                                                                               _lhsIlexLev `seq`
                                                                                                               (_lhsIpredSameScopeCounter `seq`
                                                                                                                ((case (_lhsIpredSameScopeCounter) of
                                                                                                                  { _hdOpredSameScopeCounter | _hdOpredSameScopeCounter `seq` (True) ->
                                                                                                                  (case (_lhsIlexLev) of
                                                                                                                   { _hdOlexLev | _hdOlexLev `seq` (True) ->
                                                                                                                   (case (hd_3 _hdOlexLev _hdOpredSameScopeCounter) of
                                                                                                                    { ( _hdIpredSameScopeCounter,hd_4) | True ->
                                                                                                                        (case (_hdIpredSameScopeCounter) of
                                                                                                                         { _tlOpredSameScopeCounter | _tlOpredSameScopeCounter `seq` (True) ->
                                                                                                                         (case (_lhsIlexLev) of
                                                                                                                          { _tlOlexLev | _tlOlexLev `seq` (True) ->
                                                                                                                          (case (tl_3 _tlOlexLev _tlOpredSameScopeCounter) of
                                                                                                                           { ( _tlIpredSameScopeCounter,tl_4) | True ->
                                                                                                                               (case (_tlIpredSameScopeCounter) of
                                                                                                                                { _lhsOpredSameScopeCounter | _lhsOpredSameScopeCounter `seq` (True) ->
                                                                                                                                (case ((let sem_Decls_Cons_4 :: T_Decls_4
                                                                                                                                            sem_Decls_Cons_4 =
                                                                                                                                                (\ _lhsIpatTyGam
                                                                                                                                                   _lhsItyKiSigGam ->
                                                                                                                                                     _lhsIpatTyGam `seq`
                                                                                                                                                     (_lhsItyKiSigGam `seq`
                                                                                                                                                      ((case (_lhsItyKiSigGam) of
                                                                                                                                                        { _tlOtyKiSigGam | _tlOtyKiSigGam `seq` (True) ->
                                                                                                                                                        (case (_lhsItyKiSigGam) of
                                                                                                                                                         { _hdOtyKiSigGam | _hdOtyKiSigGam `seq` (True) ->
                                                                                                                                                         (case (_lhsIpatTyGam) of
                                                                                                                                                          { _hdOpatTyGam | _hdOpatTyGam `seq` (True) ->
                                                                                                                                                          (case (hd_4 _hdOpatTyGam _hdOtyKiSigGam) of
                                                                                                                                                           { ( _hdIpatTyGam,hd_5) | True ->
                                                                                                                                                               (case (_hdIpatTyGam) of
                                                                                                                                                                { _tlOpatTyGam | _tlOpatTyGam `seq` (True) ->
                                                                                                                                                                (case (tl_4 _tlOpatTyGam _tlOtyKiSigGam) of
                                                                                                                                                                 { ( _tlIpatTyGam,tl_5) | True ->
                                                                                                                                                                     (case (_tlIpatTyGam) of
                                                                                                                                                                      { _lhsOpatTyGam | _lhsOpatTyGam `seq` (True) ->
                                                                                                                                                                      (case ((let sem_Decls_Cons_5 :: T_Decls_5
                                                                                                                                                                                  sem_Decls_Cons_5 =
                                                                                                                                                                                      (\ _lhsIpatTyKiGam
                                                                                                                                                                                         _lhsItyGam
                                                                                                                                                                                         _lhsItyTyVarMp ->
                                                                                                                                                                                           _lhsIpatTyKiGam `seq`
                                                                                                                                                                                           (_lhsItyGam `seq`
                                                                                                                                                                                            (_lhsItyTyVarMp `seq`
                                                                                                                                                                                             ((case (_lhsIpatTyKiGam) of
                                                                                                                                                                                               { _hdOpatTyKiGam | _hdOpatTyKiGam `seq` (True) ->
                                                                                                                                                                                               (case (_lhsItyTyVarMp) of
                                                                                                                                                                                                { _hdOtyTyVarMp | _hdOtyTyVarMp `seq` (True) ->
                                                                                                                                                                                                (case (_lhsItyGam) of
                                                                                                                                                                                                 { _hdOtyGam | _hdOtyGam `seq` (True) ->
                                                                                                                                                                                                 (case (hd_5 _hdOpatTyKiGam _hdOtyGam _hdOtyTyVarMp) of
                                                                                                                                                                                                  { ( _hdIpatTyKiGam,_hdItyTyVarMp,hd_6) | True ->
                                                                                                                                                                                                      (case (_hdIpatTyKiGam) of
                                                                                                                                                                                                       { _tlOpatTyKiGam | _tlOpatTyKiGam `seq` (True) ->
                                                                                                                                                                                                       (case (_hdItyTyVarMp) of
                                                                                                                                                                                                        { _tlOtyTyVarMp | _tlOtyTyVarMp `seq` (True) ->
                                                                                                                                                                                                        (case (_lhsItyGam) of
                                                                                                                                                                                                         { _tlOtyGam | _tlOtyGam `seq` (True) ->
                                                                                                                                                                                                         (case (tl_5 _tlOpatTyKiGam _tlOtyGam _tlOtyTyVarMp) of
                                                                                                                                                                                                          { ( _tlIpatTyKiGam,_tlItyTyVarMp,tl_6) | True ->
                                                                                                                                                                                                              (case (_tlIpatTyKiGam) of
                                                                                                                                                                                                               { _lhsOpatTyKiGam | _lhsOpatTyKiGam `seq` (True) ->
                                                                                                                                                                                                               (case (_tlItyTyVarMp) of
                                                                                                                                                                                                                { _lhsOtyTyVarMp | _lhsOtyTyVarMp `seq` (True) ->
                                                                                                                                                                                                                (case ((let sem_Decls_Cons_6 :: T_Decls_6
                                                                                                                                                                                                                            sem_Decls_Cons_6 =
                                                                                                                                                                                                                                (\ _lhsIpatKiVarMp
                                                                                                                                                                                                                                   _lhsIpatPolGam
                                                                                                                                                                                                                                   _lhsItyKiGam ->
                                                                                                                                                                                                                                     _lhsIpatKiVarMp `seq`
                                                                                                                                                                                                                                     (_lhsIpatPolGam `seq`
                                                                                                                                                                                                                                      (_lhsItyKiGam `seq`
                                                                                                                                                                                                                                       ((case (_lhsItyKiGam) of
                                                                                                                                                                                                                                         { _tlOtyKiGam | _tlOtyKiGam `seq` (True) ->
                                                                                                                                                                                                                                         (case (_lhsItyKiGam) of
                                                                                                                                                                                                                                          { _hdOtyKiGam | _hdOtyKiGam `seq` (True) ->
                                                                                                                                                                                                                                          (case (_lhsIpatKiVarMp) of
                                                                                                                                                                                                                                           { _hdOpatKiVarMp | _hdOpatKiVarMp `seq` (True) ->
                                                                                                                                                                                                                                           (case (_lhsIpatPolGam) of
                                                                                                                                                                                                                                            { _hdOpatPolGam | _hdOpatPolGam `seq` (True) ->
                                                                                                                                                                                                                                            (case (hd_6 _hdOpatKiVarMp _hdOpatPolGam _hdOtyKiGam) of
                                                                                                                                                                                                                                             { ( _hdIpatKiVarMp,_hdIpatPolGam,hd_7) | True ->
                                                                                                                                                                                                                                                 (case (_hdIpatKiVarMp) of
                                                                                                                                                                                                                                                  { _tlOpatKiVarMp | _tlOpatKiVarMp `seq` (True) ->
                                                                                                                                                                                                                                                  (case (_hdIpatPolGam) of
                                                                                                                                                                                                                                                   { _tlOpatPolGam | _tlOpatPolGam `seq` (True) ->
                                                                                                                                                                                                                                                   (case (tl_6 _tlOpatKiVarMp _tlOpatPolGam _tlOtyKiGam) of
                                                                                                                                                                                                                                                    { ( _tlIpatKiVarMp,_tlIpatPolGam,tl_7) | True ->
                                                                                                                                                                                                                                                        (case (_tlIpatKiVarMp) of
                                                                                                                                                                                                                                                         { _lhsOpatKiVarMp | _lhsOpatKiVarMp `seq` (True) ->
                                                                                                                                                                                                                                                         (case (_tlIpatPolGam) of
                                                                                                                                                                                                                                                          { _lhsOpatPolGam | _lhsOpatPolGam `seq` (True) ->
                                                                                                                                                                                                                                                          (case ((let sem_Decls_Cons_7 :: T_Decls_7
                                                                                                                                                                                                                                                                      sem_Decls_Cons_7 =
                                                                                                                                                                                                                                                                          (\ _lhsIgenerDataInfoMp
                                                                                                                                                                                                                                                                             _lhsIkiVarMp
                                                                                                                                                                                                                                                                             _lhsImbKnPolCtx
                                                                                                                                                                                                                                                                             _lhsIopts
                                                                                                                                                                                                                                                                             _lhsIpolGam
                                                                                                                                                                                                                                                                             _lhsIpolVarMp
                                                                                                                                                                                                                                                                             _lhsIpredScope
                                                                                                                                                                                                                                                                             _lhsItyKiGlobFreeTvarS ->
                                                                                                                                                                                                                                                                               _lhsIgenerDataInfoMp `seq`
                                                                                                                                                                                                                                                                               (_lhsIkiVarMp `seq`
                                                                                                                                                                                                                                                                                (_lhsImbKnPolCtx `seq`
                                                                                                                                                                                                                                                                                 (_lhsIopts `seq`
                                                                                                                                                                                                                                                                                  (_lhsIpolGam `seq`
                                                                                                                                                                                                                                                                                   (_lhsIpolVarMp `seq`
                                                                                                                                                                                                                                                                                    (_lhsIpredScope `seq`
                                                                                                                                                                                                                                                                                     (_lhsItyKiGlobFreeTvarS `seq`
                                                                                                                                                                                                                                                                                      ((case (_lhsItyKiGlobFreeTvarS) of
                                                                                                                                                                                                                                                                                        { _tlOtyKiGlobFreeTvarS | _tlOtyKiGlobFreeTvarS `seq` (True) ->
                                                                                                                                                                                                                                                                                        (case (_lhsIpredScope) of
                                                                                                                                                                                                                                                                                         { _tlOpredScope | _tlOpredScope `seq` (True) ->
                                                                                                                                                                                                                                                                                         (case (_lhsItyKiGlobFreeTvarS) of
                                                                                                                                                                                                                                                                                          { _hdOtyKiGlobFreeTvarS | _hdOtyKiGlobFreeTvarS `seq` (True) ->
                                                                                                                                                                                                                                                                                          (case (_lhsIpredScope) of
                                                                                                                                                                                                                                                                                           { _hdOpredScope | _hdOpredScope `seq` (True) ->
                                                                                                                                                                                                                                                                                           (case (_lhsIpolVarMp) of
                                                                                                                                                                                                                                                                                            { _hdOpolVarMp | _hdOpolVarMp `seq` (True) ->
                                                                                                                                                                                                                                                                                            (case (_lhsIpolGam) of
                                                                                                                                                                                                                                                                                             { _hdOpolGam | _hdOpolGam `seq` (True) ->
                                                                                                                                                                                                                                                                                             (case (_lhsIopts) of
                                                                                                                                                                                                                                                                                              { _hdOopts | _hdOopts `seq` (True) ->
                                                                                                                                                                                                                                                                                              (case (_lhsImbKnPolCtx) of
                                                                                                                                                                                                                                                                                               { _hdOmbKnPolCtx | _hdOmbKnPolCtx `seq` (True) ->
                                                                                                                                                                                                                                                                                               (case (_lhsIkiVarMp) of
                                                                                                                                                                                                                                                                                                { _hdOkiVarMp | _hdOkiVarMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                (case (_lhsIgenerDataInfoMp) of
                                                                                                                                                                                                                                                                                                 { _hdOgenerDataInfoMp | _hdOgenerDataInfoMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                 (case (hd_7 _hdOgenerDataInfoMp _hdOkiVarMp _hdOmbKnPolCtx _hdOopts _hdOpolGam _hdOpolVarMp _hdOpredScope _hdOtyKiGlobFreeTvarS) of
                                                                                                                                                                                                                                                                                                  { ( _hdIgenerDataInfoL,_hdIgenerDataInfoMp,_hdIkiVarMp,_hdIpolVarMp,hd_8) | True ->
                                                                                                                                                                                                                                                                                                      (case (_hdIpolVarMp) of
                                                                                                                                                                                                                                                                                                       { _tlOpolVarMp | _tlOpolVarMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                       (case (_lhsIpolGam) of
                                                                                                                                                                                                                                                                                                        { _tlOpolGam | _tlOpolGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                        (case (_lhsIopts) of
                                                                                                                                                                                                                                                                                                         { _tlOopts | _tlOopts `seq` (True) ->
                                                                                                                                                                                                                                                                                                         (case (_lhsImbKnPolCtx) of
                                                                                                                                                                                                                                                                                                          { _tlOmbKnPolCtx | _tlOmbKnPolCtx `seq` (True) ->
                                                                                                                                                                                                                                                                                                          (case (_hdIkiVarMp) of
                                                                                                                                                                                                                                                                                                           { _tlOkiVarMp | _tlOkiVarMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                           (case (_hdIgenerDataInfoMp) of
                                                                                                                                                                                                                                                                                                            { _tlOgenerDataInfoMp | _tlOgenerDataInfoMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                            (case (tl_7 _tlOgenerDataInfoMp _tlOkiVarMp _tlOmbKnPolCtx _tlOopts _tlOpolGam _tlOpolVarMp _tlOpredScope _tlOtyKiGlobFreeTvarS) of
                                                                                                                                                                                                                                                                                                             { ( _tlIgenerDataInfoL,_tlIgenerDataInfoMp,_tlIkiVarMp,_tlIpolVarMp,tl_8) | True ->
                                                                                                                                                                                                                                                                                                                 (case (_hdIgenerDataInfoL ++ _tlIgenerDataInfoL) of
                                                                                                                                                                                                                                                                                                                  { _lhsOgenerDataInfoL | _lhsOgenerDataInfoL `seq` (True) ->
                                                                                                                                                                                                                                                                                                                  (case (_tlIgenerDataInfoMp) of
                                                                                                                                                                                                                                                                                                                   { _lhsOgenerDataInfoMp | _lhsOgenerDataInfoMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                   (case (_tlIkiVarMp) of
                                                                                                                                                                                                                                                                                                                    { _lhsOkiVarMp | _lhsOkiVarMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                    (case (_tlIpolVarMp) of
                                                                                                                                                                                                                                                                                                                     { _lhsOpolVarMp | _lhsOpolVarMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                     (case ((let sem_Decls_Cons_8 :: T_Decls_8
                                                                                                                                                                                                                                                                                                                                 sem_Decls_Cons_8 =
                                                                                                                                                                                                                                                                                                                                     (\ _lhsIpatClGam1 ->
                                                                                                                                                                                                                                                                                                                                          _lhsIpatClGam1 `seq`
                                                                                                                                                                                                                                                                                                                                          ((case (_lhsIpatClGam1) of
                                                                                                                                                                                                                                                                                                                                            { _hdOpatClGam1 | _hdOpatClGam1 `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                            (case (hd_8 _hdOpatClGam1) of
                                                                                                                                                                                                                                                                                                                                             { ( _hdIpatClGam1,hd_9) | True ->
                                                                                                                                                                                                                                                                                                                                                 (case (_hdIpatClGam1) of
                                                                                                                                                                                                                                                                                                                                                  { _tlOpatClGam1 | _tlOpatClGam1 `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                  (case (tl_8 _tlOpatClGam1) of
                                                                                                                                                                                                                                                                                                                                                   { ( _tlIpatClGam1,tl_9) | True ->
                                                                                                                                                                                                                                                                                                                                                       (case (_tlIpatClGam1) of
                                                                                                                                                                                                                                                                                                                                                        { _lhsOpatClGam1 | _lhsOpatClGam1 `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                        (case ((let sem_Decls_Cons_9 :: T_Decls_9
                                                                                                                                                                                                                                                                                                                                                                    sem_Decls_Cons_9 =
                                                                                                                                                                                                                                                                                                                                                                        (\ _lhsIfinKiVarMp
                                                                                                                                                                                                                                                                                                                                                                           _lhsIfinTyKiGam
                                                                                                                                                                                                                                                                                                                                                                           _lhsIpatClGam2
                                                                                                                                                                                                                                                                                                                                                                           _lhsItyTyTySigFreeTvarS ->
                                                                                                                                                                                                                                                                                                                                                                             _lhsIfinKiVarMp `seq`
                                                                                                                                                                                                                                                                                                                                                                             (_lhsIfinTyKiGam `seq`
                                                                                                                                                                                                                                                                                                                                                                              (_lhsIpatClGam2 `seq`
                                                                                                                                                                                                                                                                                                                                                                               (_lhsItyTyTySigFreeTvarS `seq`
                                                                                                                                                                                                                                                                                                                                                                                ((case (_lhsItyTyTySigFreeTvarS) of
                                                                                                                                                                                                                                                                                                                                                                                  { _tlOtyTyTySigFreeTvarS | _tlOtyTyTySigFreeTvarS `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                  (case (_lhsItyTyTySigFreeTvarS) of
                                                                                                                                                                                                                                                                                                                                                                                   { _hdOtyTyTySigFreeTvarS | _hdOtyTyTySigFreeTvarS `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                   (case (_lhsIpatClGam2) of
                                                                                                                                                                                                                                                                                                                                                                                    { _hdOpatClGam2 | _hdOpatClGam2 `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                    (case (_lhsIfinTyKiGam) of
                                                                                                                                                                                                                                                                                                                                                                                     { _hdOfinTyKiGam | _hdOfinTyKiGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                     (case (_lhsIfinKiVarMp) of
                                                                                                                                                                                                                                                                                                                                                                                      { _hdOfinKiVarMp | _hdOfinKiVarMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                      (case (hd_9 _hdOfinKiVarMp _hdOfinTyKiGam _hdOpatClGam2 _hdOtyTyTySigFreeTvarS) of
                                                                                                                                                                                                                                                                                                                                                                                       { ( _hdIpatClGam2,hd_10) | True ->
                                                                                                                                                                                                                                                                                                                                                                                           (case (_hdIpatClGam2) of
                                                                                                                                                                                                                                                                                                                                                                                            { _tlOpatClGam2 | _tlOpatClGam2 `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                            (case (_lhsIfinTyKiGam) of
                                                                                                                                                                                                                                                                                                                                                                                             { _tlOfinTyKiGam | _tlOfinTyKiGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                             (case (_lhsIfinKiVarMp) of
                                                                                                                                                                                                                                                                                                                                                                                              { _tlOfinKiVarMp | _tlOfinKiVarMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                              (case (tl_9 _tlOfinKiVarMp _tlOfinTyKiGam _tlOpatClGam2 _tlOtyTyTySigFreeTvarS) of
                                                                                                                                                                                                                                                                                                                                                                                               { ( _tlIpatClGam2,tl_10) | True ->
                                                                                                                                                                                                                                                                                                                                                                                                   (case (_tlIpatClGam2) of
                                                                                                                                                                                                                                                                                                                                                                                                    { _lhsOpatClGam2 | _lhsOpatClGam2 `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                    (case ((let sem_Decls_Cons_10 :: T_Decls_10
                                                                                                                                                                                                                                                                                                                                                                                                                sem_Decls_Cons_10 =
                                                                                                                                                                                                                                                                                                                                                                                                                    (\ _lhsIclGam
                                                                                                                                                                                                                                                                                                                                                                                                                       _lhsIgathDataGam ->
                                                                                                                                                                                                                                                                                                                                                                                                                         _lhsIclGam `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                         (_lhsIgathDataGam `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                          ((case (_lhsIgathDataGam) of
                                                                                                                                                                                                                                                                                                                                                                                                                            { _hdOgathDataGam | _hdOgathDataGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                            (case (_lhsIclGam) of
                                                                                                                                                                                                                                                                                                                                                                                                                             { _hdOclGam | _hdOclGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                             (case (hd_10 _hdOclGam _hdOgathDataGam) of
                                                                                                                                                                                                                                                                                                                                                                                                                              { ( _hdIgathDataGam,_hdIgathDeclDataGam,_hdIgathTySigGam,_hdIgathTySigVarMp,hd_11) | True ->
                                                                                                                                                                                                                                                                                                                                                                                                                                  (case (_hdIgathDataGam) of
                                                                                                                                                                                                                                                                                                                                                                                                                                   { _tlOgathDataGam | _tlOgathDataGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                   (case (_lhsIclGam) of
                                                                                                                                                                                                                                                                                                                                                                                                                                    { _tlOclGam | _tlOclGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                    (case (tl_10 _tlOclGam _tlOgathDataGam) of
                                                                                                                                                                                                                                                                                                                                                                                                                                     { ( _tlIgathDataGam,_tlIgathDeclDataGam,_tlIgathTySigGam,_tlIgathTySigVarMp,tl_11) | True ->
                                                                                                                                                                                                                                                                                                                                                                                                                                         (case (_tlIgathDataGam) of
                                                                                                                                                                                                                                                                                                                                                                                                                                          { _lhsOgathDataGam | _lhsOgathDataGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                          (case (_hdIgathDeclDataGam `gamUnion` _tlIgathDeclDataGam) of
                                                                                                                                                                                                                                                                                                                                                                                                                                           { _lhsOgathDeclDataGam | _lhsOgathDeclDataGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                           (case (_hdIgathTySigGam `gamAddGam` _tlIgathTySigGam) of
                                                                                                                                                                                                                                                                                                                                                                                                                                            { _lhsOgathTySigGam | _lhsOgathTySigGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                            (case (_hdIgathTySigVarMp `varUpd` _tlIgathTySigVarMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                             { _lhsOgathTySigVarMp | _lhsOgathTySigVarMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                             (case ((let sem_Decls_Cons_11 :: T_Decls_11
                                                                                                                                                                                                                                                                                                                                                                                                                                                         sem_Decls_Cons_11 =
                                                                                                                                                                                                                                                                                                                                                                                                                                                             (\ _lhsIdataGam ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  _lhsIdataGam `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ((case (_lhsIdataGam) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    { _tlOdataGam | _tlOdataGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (case (tl_11 _tlOdataGam) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                     { ( _tlIchrClassDeclSq,_tlIchrInstDeclSq,_tlIgathClDfGam,tl_12) | True ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                         (case (_lhsIdataGam) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          { _hdOdataGam | _hdOdataGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          (case (hd_11 _hdOdataGam) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                           { ( _hdIchrClassDeclSq,_hdIchrInstDeclSq,_hdIgathClDfGam,hd_12) | True ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                               (case (_hdIchrClassDeclSq `Seq.union` _tlIchrClassDeclSq) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                { _lhsOchrClassDeclSq | _lhsOchrClassDeclSq `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (case (_hdIchrInstDeclSq `Seq.union` _tlIchrInstDeclSq) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 { _lhsOchrInstDeclSq | _lhsOchrInstDeclSq `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 (case (_hdIgathClDfGam `gamUnion` _tlIgathClDfGam) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  { _lhsOgathClDfGam | _lhsOgathClDfGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (case ((let sem_Decls_Cons_12 :: T_Decls_12
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              sem_Decls_Cons_12 =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (\ _lhsIpatTyVarMp
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     _lhsIpatValGam
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     _lhsItvKiVarMp
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     _lhsItySigGam
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     _lhsItySigVarMp ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       _lhsIpatTyVarMp `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       (_lhsIpatValGam `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (_lhsItvKiVarMp `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         (_lhsItySigGam `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          (_lhsItySigVarMp `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           ((case (_lhsItySigVarMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             { _tlOtySigVarMp | _tlOtySigVarMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             (case (_lhsItySigGam) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              { _tlOtySigGam | _tlOtySigGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              (case (_lhsItvKiVarMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               { _tlOtvKiVarMp | _tlOtvKiVarMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               (case (_lhsItySigVarMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                { _hdOtySigVarMp | _hdOtySigVarMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (case (_lhsItySigGam) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 { _hdOtySigGam | _hdOtySigGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 (case (_lhsItvKiVarMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  { _hdOtvKiVarMp | _hdOtvKiVarMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (case (_lhsIpatValGam) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   { _hdOpatValGam | _hdOpatValGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   (case (_lhsIpatTyVarMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    { _hdOpatTyVarMp | _hdOpatTyVarMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (case (hd_12 _hdOpatTyVarMp _hdOpatValGam _hdOtvKiVarMp _hdOtySigGam _hdOtySigVarMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     { ( _hdIpatTyVarMp,_hdIpatValGam,hd_13) | True ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         (case (_hdIpatValGam) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          { _tlOpatValGam | _tlOpatValGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          (case (_hdIpatTyVarMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           { _tlOpatTyVarMp | _tlOpatTyVarMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           (case (tl_12 _tlOpatTyVarMp _tlOpatValGam _tlOtvKiVarMp _tlOtySigGam _tlOtySigVarMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            { ( _tlIpatTyVarMp,_tlIpatValGam,tl_13) | True ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (case (_tlIpatTyVarMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 { _lhsOpatTyVarMp | _lhsOpatTyVarMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 (case (_tlIpatValGam) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  { _lhsOpatValGam | _lhsOpatValGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (case ((let sem_Decls_Cons_13 :: T_Decls_13
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              sem_Decls_Cons_13 =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (\ _lhsIchrStore
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     _lhsIclDfGam
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     _lhsItyTyGlobFreeTvarS
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     _lhsItyVarMp
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     _lhsIvalGam
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     _lhsIvalTyGlobFreeTvarS ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       _lhsIchrStore `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       (_lhsIclDfGam `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (_lhsItyTyGlobFreeTvarS `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         (_lhsItyVarMp `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          (_lhsIvalGam `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           (_lhsIvalTyGlobFreeTvarS `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ((case (_lhsIvalTyGlobFreeTvarS) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              { _tlOvalTyGlobFreeTvarS | _tlOvalTyGlobFreeTvarS `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              (case (_lhsIvalGam) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               { _tlOvalGam | _tlOvalGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               (case (_lhsIvalTyGlobFreeTvarS) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                { _hdOvalTyGlobFreeTvarS | _hdOvalTyGlobFreeTvarS `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (case (_lhsIvalGam) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 { _hdOvalGam | _hdOvalGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 (case (_lhsItyVarMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  { _hdOtyVarMp | _hdOtyVarMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (case (_lhsItyTyGlobFreeTvarS) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   { _hdOtyTyGlobFreeTvarS | _hdOtyTyGlobFreeTvarS `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   (case (_lhsIclDfGam) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    { _hdOclDfGam | _hdOclDfGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (case (_lhsIchrStore) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     { _hdOchrStore | _hdOchrStore `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     (case (hd_13 _hdOchrStore _hdOclDfGam _hdOtyTyGlobFreeTvarS _hdOtyVarMp _hdOvalGam _hdOvalTyGlobFreeTvarS) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      { ( _hdIgathCnstrMp,_hdIgathRangeMp,_hdIintlTyKiGam,_hdInoLetQuantTyVarIdS,_hdIscopeGam,_hdItyVarMp,hd_14) | True ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          (case (_hdItyVarMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           { _tlOtyVarMp | _tlOtyVarMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           (case (_lhsItyTyGlobFreeTvarS) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            { _tlOtyTyGlobFreeTvarS | _tlOtyTyGlobFreeTvarS `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (case (_lhsIclDfGam) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             { _tlOclDfGam | _tlOclDfGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             (case (_lhsIchrStore) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              { _tlOchrStore | _tlOchrStore `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              (case (tl_13 _tlOchrStore _tlOclDfGam _tlOtyTyGlobFreeTvarS _tlOtyVarMp _tlOvalGam _tlOvalTyGlobFreeTvarS) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               { ( _tlIgathCnstrMp,_tlIgathRangeMp,_tlIintlTyKiGam,_tlInoLetQuantTyVarIdS,_tlIscopeGam,_tlItyVarMp,tl_14) | True ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   (case (_hdIgathCnstrMp `cnstrMpUnion` _tlIgathCnstrMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    { _lhsOgathCnstrMp | _lhsOgathCnstrMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (case (_hdIgathRangeMp `Map.union` _tlIgathRangeMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     { _lhsOgathRangeMp | _lhsOgathRangeMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     (case (_hdIintlTyKiGam `gamUnion` _tlIintlTyKiGam) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      { _lhsOintlTyKiGam | _lhsOintlTyKiGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      (case (_hdInoLetQuantTyVarIdS `Set.union` _tlInoLetQuantTyVarIdS) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       { _lhsOnoLetQuantTyVarIdS | _lhsOnoLetQuantTyVarIdS `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       (case (_hdIscopeGam `gamUnion` _tlIscopeGam) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        { _lhsOscopeGam | _lhsOscopeGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (case (_tlItyVarMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         { _lhsOtyVarMp | _lhsOtyVarMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         (case ((let sem_Decls_Cons_14 :: T_Decls_14
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     sem_Decls_Cons_14 =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         (\ _lhsIcSubst
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _lhsIchrEvidBindMp
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _lhsIchrScopeBindMp
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _lhsIfinTyVarMp
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _lhsIfinValGam
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _lhsIisStrict
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _lhsIkiSigGam
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _lhsImoduleNm
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _lhsIrangeMp
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _lhsIsysfEnv
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _lhsItr ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              _lhsIcSubst `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              (_lhsIchrEvidBindMp `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               (_lhsIchrScopeBindMp `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (_lhsIfinTyVarMp `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 (_lhsIfinValGam `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (_lhsIisStrict `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   (_lhsIkiSigGam `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (_lhsImoduleNm `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     (_lhsIrangeMp `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      (_lhsIsysfEnv `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       (_lhsItr `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ((case (_lhsIsysfEnv) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          { _tlOsysfEnv | _tlOsysfEnv `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          (case (_lhsIrangeMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           { _tlOrangeMp | _tlOrangeMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           (case (_lhsIfinValGam) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            { _tlOfinValGam | _tlOfinValGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (case (_lhsIfinTyVarMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             { _tlOfinTyVarMp | _tlOfinTyVarMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             (case (_lhsIsysfEnv) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              { _hdOsysfEnv | _hdOsysfEnv `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              (case (_lhsIrangeMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               { _hdOrangeMp | _hdOrangeMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               (case (_lhsIfinValGam) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                { _hdOfinValGam | _hdOfinValGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (case (_lhsIfinTyVarMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 { _hdOfinTyVarMp | _hdOfinTyVarMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 (case (_lhsItr) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  { _tlOtr | _tlOtr `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (case (_lhsImoduleNm) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   { _tlOmoduleNm | _tlOmoduleNm `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   (case (_lhsIkiSigGam) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    { _tlOkiSigGam | _tlOkiSigGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (case (_lhsIisStrict) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     { _tlOisStrict | _tlOisStrict `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     (case (_lhsIchrScopeBindMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      { _tlOchrScopeBindMp | _tlOchrScopeBindMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      (case (_lhsIchrEvidBindMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       { _tlOchrEvidBindMp | _tlOchrEvidBindMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       (case (_lhsIchrScopeBindMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        { _hdOchrScopeBindMp | _hdOchrScopeBindMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (case (_lhsIchrEvidBindMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         { _hdOchrEvidBindMp | _hdOchrEvidBindMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         (case (_lhsIcSubst) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          { _hdOcSubst | _hdOcSubst `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          (case (_lhsItr) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           { _hdOtr | _hdOtr `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           (case (_lhsImoduleNm) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            { _hdOmoduleNm | _hdOmoduleNm `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (case (_lhsIkiSigGam) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             { _hdOkiSigGam | _hdOkiSigGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             (case (_lhsIisStrict) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              { _hdOisStrict | _hdOisStrict `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              (case (hd_14 _hdOcSubst _hdOchrEvidBindMp _hdOchrScopeBindMp _hdOfinTyVarMp _hdOfinValGam _hdOisStrict _hdOkiSigGam _hdOmoduleNm _hdOrangeMp _hdOsysfEnv _hdOtr) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               { ( _hdIallErrSq,_hdIbangEvalL,_hdIcSubst,_hdIerrSq,_hdIffeCBindL,_hdIffiCBindL,_hdIgathHiddenExports,_hdIgathLamMp,_hdIgathMentrelFilterMp,_hdIgathTvKiVarMp,_hdIorphanS,_hdIpp,_hdIppAST,_hdItrpp,_hdItyCBindL,_hdIvalCBindL) | True ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   (case (_hdIcSubst) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    { _tlOcSubst | _tlOcSubst `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (case (tl_14 _tlOcSubst _tlOchrEvidBindMp _tlOchrScopeBindMp _tlOfinTyVarMp _tlOfinValGam _tlOisStrict _tlOkiSigGam _tlOmoduleNm _tlOrangeMp _tlOsysfEnv _tlOtr) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     { ( _tlIallErrSq,_tlIbangEvalL,_tlIcSubst,_tlIerrSq,_tlIffeCBindL,_tlIffiCBindL,_tlIgathHiddenExports,_tlIgathLamMp,_tlIgathMentrelFilterMp,_tlIgathTvKiVarMp,_tlIorphanS,_tlIpp,_tlIppAST,_tlItrpp,_tlItyCBindL,_tlIvalCBindL) | True ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         (case (Seq.unions [_hdIerrSq, _hdIallErrSq, _tlIallErrSq]) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          { _lhsOallErrSq | _lhsOallErrSq `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          (case (_hdIbangEvalL ++ _tlIbangEvalL) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           { _lhsObangEvalL | _lhsObangEvalL `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           (case (_tlIcSubst) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            { _lhsOcSubst | _lhsOcSubst `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (case (Seq.empty) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             { _lhsOerrSq | _lhsOerrSq `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             (case (_hdIffeCBindL ++ _tlIffeCBindL) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              { _lhsOffeCBindL | _lhsOffeCBindL `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              (case (_hdIffiCBindL ++ _tlIffiCBindL) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               { _lhsOffiCBindL | _lhsOffiCBindL `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               (case (_hdIgathHiddenExports `Seq.union` _tlIgathHiddenExports) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                { _lhsOgathHiddenExports | _lhsOgathHiddenExports `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (case (_hdIgathLamMp `lamMpUnionBindAspMp` _tlIgathLamMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 { _lhsOgathLamMp | _lhsOgathLamMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 (case (_hdIgathMentrelFilterMp `mentrelFilterMpUnion` _tlIgathMentrelFilterMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  { _lhsOgathMentrelFilterMp | _lhsOgathMentrelFilterMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (case (_hdIgathTvKiVarMp `varmpUnion` _tlIgathTvKiVarMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   { _lhsOgathTvKiVarMp | _lhsOgathTvKiVarMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   (case (_hdIorphanS `Set.union` _tlIorphanS) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    { _lhsOorphanS | _lhsOorphanS `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (case (ppErrsSq _hdIerrSq) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     { _errPP | _errPP `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     (case (_hdIpp
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            >-< _errPP
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            >-< _tlIpp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      { _lhsOpp | _lhsOpp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      (case (trppEmpty) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       { _trppHere | _trppHere `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       (case (ppNestTrPP _lhsIopts ["Decls","Cons"] [] [_hdIppAST,_tlIppAST] _trppHere) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        { _lhsOppAST | _lhsOppAST `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (case (_hdItrpp >< _tlItrpp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         { _lhsOtrpp | _lhsOtrpp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         (case (_hdItyCBindL ++ _tlItyCBindL) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          { _lhsOtyCBindL | _lhsOtyCBindL `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          (case (_hdIvalCBindL ++ _tlIvalCBindL) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           { _lhsOvalCBindL | _lhsOvalCBindL `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           ( _lhsOallErrSq,_lhsObangEvalL,_lhsOcSubst,_lhsOerrSq,_lhsOffeCBindL,_lhsOffiCBindL,_lhsOgathHiddenExports,_lhsOgathLamMp,_lhsOgathMentrelFilterMp,_lhsOgathTvKiVarMp,_lhsOorphanS,_lhsOpp,_lhsOppAST,_lhsOtrpp,_lhsOtyCBindL,_lhsOvalCBindL) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) })))))))))))))
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 in  sem_Decls_Cons_14)) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          { ( sem_Decls_14) | True ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ( _lhsOgathCnstrMp,_lhsOgathRangeMp,_lhsOintlTyKiGam,_lhsOnoLetQuantTyVarIdS,_lhsOscopeGam,_lhsOtyVarMp,sem_Decls_14) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }))))))))
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          in  sem_Decls_Cons_13)) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   { ( sem_Decls_13) | True ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   ( _lhsOpatTyVarMp,_lhsOpatValGam,sem_Decls_13) }) }) }) }) }) }) }) }) }) }) }) }) }) }) })))))))
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          in  sem_Decls_Cons_12)) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   { ( sem_Decls_12) | True ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   ( _lhsOchrClassDeclSq,_lhsOchrInstDeclSq,_lhsOgathClDfGam,sem_Decls_12) }) }) }) }) }) }) }) })))
                                                                                                                                                                                                                                                                                                                                                                                                                                                     in  sem_Decls_Cons_11)) of
                                                                                                                                                                                                                                                                                                                                                                                                                                              { ( sem_Decls_11) | True ->
                                                                                                                                                                                                                                                                                                                                                                                                                                              ( _lhsOgathDataGam,_lhsOgathDeclDataGam,_lhsOgathTySigGam,_lhsOgathTySigVarMp,sem_Decls_11) }) }) }) }) }) }) }) }) }) }) }))))
                                                                                                                                                                                                                                                                                                                                                                                                            in  sem_Decls_Cons_10)) of
                                                                                                                                                                                                                                                                                                                                                                                                     { ( sem_Decls_10) | True ->
                                                                                                                                                                                                                                                                                                                                                                                                     ( _lhsOpatClGam2,sem_Decls_10) }) }) }) }) }) }) }) }) }) }) }) }))))))
                                                                                                                                                                                                                                                                                                                                                                in  sem_Decls_Cons_9)) of
                                                                                                                                                                                                                                                                                                                                                         { ( sem_Decls_9) | True ->
                                                                                                                                                                                                                                                                                                                                                         ( _lhsOpatClGam1,sem_Decls_9) }) }) }) }) }) })))
                                                                                                                                                                                                                                                                                                                             in  sem_Decls_Cons_8)) of
                                                                                                                                                                                                                                                                                                                      { ( sem_Decls_8) | True ->
                                                                                                                                                                                                                                                                                                                      ( _lhsOgenerDataInfoL,_lhsOgenerDataInfoMp,_lhsOkiVarMp,_lhsOpolVarMp,sem_Decls_8) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }))))))))))
                                                                                                                                                                                                                                                                  in  sem_Decls_Cons_7)) of
                                                                                                                                                                                                                                                           { ( sem_Decls_7) | True ->
                                                                                                                                                                                                                                                           ( _lhsOpatKiVarMp,_lhsOpatPolGam,sem_Decls_7) }) }) }) }) }) }) }) }) }) }) })))))
                                                                                                                                                                                                                        in  sem_Decls_Cons_6)) of
                                                                                                                                                                                                                 { ( sem_Decls_6) | True ->
                                                                                                                                                                                                                 ( _lhsOpatTyKiGam,_lhsOtyTyVarMp,sem_Decls_6) }) }) }) }) }) }) }) }) }) }) })))))
                                                                                                                                                                              in  sem_Decls_Cons_5)) of
                                                                                                                                                                       { ( sem_Decls_5) | True ->
                                                                                                                                                                       ( _lhsOpatTyGam,sem_Decls_5) }) }) }) }) }) }) }) }))))
                                                                                                                                        in  sem_Decls_Cons_4)) of
                                                                                                                                 { ( sem_Decls_4) | True ->
                                                                                                                                 ( _lhsOpredSameScopeCounter,sem_Decls_4) }) }) }) }) }) }) }) }))))
                                                                                                  in  sem_Decls_Cons_3)) of
                                                                                           { ( sem_Decls_3) | True ->
                                                                                           ( _lhsOgathTyKiSigGam,sem_Decls_3) }) }) }) }) }) })))
                                                               in  sem_Decls_Cons_2)) of
                                                        { ( sem_Decls_2) | True ->
                                                        ( _lhsOgUniq,_lhsOgathKiSigGam,_lhsOhasInstDecl,sem_Decls_2) }) }) }) }) }) }) }) }) }) }))))
                       in  sem_Decls_Cons_1)) of
                { ( sem_Decls_1) | True ->
                ( _lhsOrange,sem_Decls_1) }) }) }) })

sem_Decls_Nil :: T_Decls

sem_Decls_Nil =
    (case (emptyRange) of
     { _lhsOrange | _lhsOrange `seq` (True) ->
     (case ((let sem_Decls_Nil_1 :: T_Decls_1
                 sem_Decls_Nil_1 =
                     (\ _lhsIgUniq
                        _lhsIgathKiSigGam ->
                          _lhsIgUniq `seq`
                          (_lhsIgathKiSigGam `seq`
                           ((case (_lhsIgUniq) of
                             { _lhsOgUniq | _lhsOgUniq `seq` (True) ->
                             (case (_lhsIgathKiSigGam) of
                              { _lhsOgathKiSigGam | _lhsOgathKiSigGam `seq` (True) ->
                              (case (False) of
                               { _lhsOhasInstDecl | _lhsOhasInstDecl `seq` (True) ->
                               (case ((let sem_Decls_Nil_2 :: T_Decls_2
                                           sem_Decls_Nil_2 =
                                               (\ _lhsIkiGam ->
                                                    _lhsIkiGam `seq`
                                                    ((case (emptyGam) of
                                                      { _lhsOgathTyKiSigGam | _lhsOgathTyKiSigGam `seq` (True) ->
                                                      (case ((let sem_Decls_Nil_3 :: T_Decls_3
                                                                  sem_Decls_Nil_3 =
                                                                      (\ _lhsIlexLev
                                                                         _lhsIpredSameScopeCounter ->
                                                                           _lhsIlexLev `seq`
                                                                           (_lhsIpredSameScopeCounter `seq`
                                                                            ((case (_lhsIpredSameScopeCounter) of
                                                                              { _lhsOpredSameScopeCounter | _lhsOpredSameScopeCounter `seq` (True) ->
                                                                              (case ((let sem_Decls_Nil_4 :: T_Decls_4
                                                                                          sem_Decls_Nil_4 =
                                                                                              (\ _lhsIpatTyGam
                                                                                                 _lhsItyKiSigGam ->
                                                                                                   _lhsIpatTyGam `seq`
                                                                                                   (_lhsItyKiSigGam `seq`
                                                                                                    ((case (_lhsIpatTyGam) of
                                                                                                      { _lhsOpatTyGam | _lhsOpatTyGam `seq` (True) ->
                                                                                                      (case ((let sem_Decls_Nil_5 :: T_Decls_5
                                                                                                                  sem_Decls_Nil_5 =
                                                                                                                      (\ _lhsIpatTyKiGam
                                                                                                                         _lhsItyGam
                                                                                                                         _lhsItyTyVarMp ->
                                                                                                                           _lhsIpatTyKiGam `seq`
                                                                                                                           (_lhsItyGam `seq`
                                                                                                                            (_lhsItyTyVarMp `seq`
                                                                                                                             ((case (_lhsIpatTyKiGam) of
                                                                                                                               { _lhsOpatTyKiGam | _lhsOpatTyKiGam `seq` (True) ->
                                                                                                                               (case (_lhsItyTyVarMp) of
                                                                                                                                { _lhsOtyTyVarMp | _lhsOtyTyVarMp `seq` (True) ->
                                                                                                                                (case ((let sem_Decls_Nil_6 :: T_Decls_6
                                                                                                                                            sem_Decls_Nil_6 =
                                                                                                                                                (\ _lhsIpatKiVarMp
                                                                                                                                                   _lhsIpatPolGam
                                                                                                                                                   _lhsItyKiGam ->
                                                                                                                                                     _lhsIpatKiVarMp `seq`
                                                                                                                                                     (_lhsIpatPolGam `seq`
                                                                                                                                                      (_lhsItyKiGam `seq`
                                                                                                                                                       ((case (_lhsIpatKiVarMp) of
                                                                                                                                                         { _lhsOpatKiVarMp | _lhsOpatKiVarMp `seq` (True) ->
                                                                                                                                                         (case (_lhsIpatPolGam) of
                                                                                                                                                          { _lhsOpatPolGam | _lhsOpatPolGam `seq` (True) ->
                                                                                                                                                          (case ((let sem_Decls_Nil_7 :: T_Decls_7
                                                                                                                                                                      sem_Decls_Nil_7 =
                                                                                                                                                                          (\ _lhsIgenerDataInfoMp
                                                                                                                                                                             _lhsIkiVarMp
                                                                                                                                                                             _lhsImbKnPolCtx
                                                                                                                                                                             _lhsIopts
                                                                                                                                                                             _lhsIpolGam
                                                                                                                                                                             _lhsIpolVarMp
                                                                                                                                                                             _lhsIpredScope
                                                                                                                                                                             _lhsItyKiGlobFreeTvarS ->
                                                                                                                                                                               _lhsIgenerDataInfoMp `seq`
                                                                                                                                                                               (_lhsIkiVarMp `seq`
                                                                                                                                                                                (_lhsImbKnPolCtx `seq`
                                                                                                                                                                                 (_lhsIopts `seq`
                                                                                                                                                                                  (_lhsIpolGam `seq`
                                                                                                                                                                                   (_lhsIpolVarMp `seq`
                                                                                                                                                                                    (_lhsIpredScope `seq`
                                                                                                                                                                                     (_lhsItyKiGlobFreeTvarS `seq`
                                                                                                                                                                                      ((case ([]) of
                                                                                                                                                                                        { _lhsOgenerDataInfoL | _lhsOgenerDataInfoL `seq` (True) ->
                                                                                                                                                                                        (case (_lhsIgenerDataInfoMp) of
                                                                                                                                                                                         { _lhsOgenerDataInfoMp | _lhsOgenerDataInfoMp `seq` (True) ->
                                                                                                                                                                                         (case (_lhsIkiVarMp) of
                                                                                                                                                                                          { _lhsOkiVarMp | _lhsOkiVarMp `seq` (True) ->
                                                                                                                                                                                          (case (_lhsIpolVarMp) of
                                                                                                                                                                                           { _lhsOpolVarMp | _lhsOpolVarMp `seq` (True) ->
                                                                                                                                                                                           (case ((let sem_Decls_Nil_8 :: T_Decls_8
                                                                                                                                                                                                       sem_Decls_Nil_8 =
                                                                                                                                                                                                           (\ _lhsIpatClGam1 ->
                                                                                                                                                                                                                _lhsIpatClGam1 `seq`
                                                                                                                                                                                                                ((case (_lhsIpatClGam1) of
                                                                                                                                                                                                                  { _lhsOpatClGam1 | _lhsOpatClGam1 `seq` (True) ->
                                                                                                                                                                                                                  (case ((let sem_Decls_Nil_9 :: T_Decls_9
                                                                                                                                                                                                                              sem_Decls_Nil_9 =
                                                                                                                                                                                                                                  (\ _lhsIfinKiVarMp
                                                                                                                                                                                                                                     _lhsIfinTyKiGam
                                                                                                                                                                                                                                     _lhsIpatClGam2
                                                                                                                                                                                                                                     _lhsItyTyTySigFreeTvarS ->
                                                                                                                                                                                                                                       _lhsIfinKiVarMp `seq`
                                                                                                                                                                                                                                       (_lhsIfinTyKiGam `seq`
                                                                                                                                                                                                                                        (_lhsIpatClGam2 `seq`
                                                                                                                                                                                                                                         (_lhsItyTyTySigFreeTvarS `seq`
                                                                                                                                                                                                                                          ((case (_lhsIpatClGam2) of
                                                                                                                                                                                                                                            { _lhsOpatClGam2 | _lhsOpatClGam2 `seq` (True) ->
                                                                                                                                                                                                                                            (case ((let sem_Decls_Nil_10 :: T_Decls_10
                                                                                                                                                                                                                                                        sem_Decls_Nil_10 =
                                                                                                                                                                                                                                                            (\ _lhsIclGam
                                                                                                                                                                                                                                                               _lhsIgathDataGam ->
                                                                                                                                                                                                                                                                 _lhsIclGam `seq`
                                                                                                                                                                                                                                                                 (_lhsIgathDataGam `seq`
                                                                                                                                                                                                                                                                  ((case (_lhsIgathDataGam) of
                                                                                                                                                                                                                                                                    { _lhsOgathDataGam | _lhsOgathDataGam `seq` (True) ->
                                                                                                                                                                                                                                                                    (case (emptyGam) of
                                                                                                                                                                                                                                                                     { _lhsOgathDeclDataGam | _lhsOgathDeclDataGam `seq` (True) ->
                                                                                                                                                                                                                                                                     (case (emptyGam) of
                                                                                                                                                                                                                                                                      { _lhsOgathTySigGam | _lhsOgathTySigGam `seq` (True) ->
                                                                                                                                                                                                                                                                      (case (emptyVarMp) of
                                                                                                                                                                                                                                                                       { _lhsOgathTySigVarMp | _lhsOgathTySigVarMp `seq` (True) ->
                                                                                                                                                                                                                                                                       (case ((let sem_Decls_Nil_11 :: T_Decls_11
                                                                                                                                                                                                                                                                                   sem_Decls_Nil_11 =
                                                                                                                                                                                                                                                                                       (\ _lhsIdataGam ->
                                                                                                                                                                                                                                                                                            _lhsIdataGam `seq`
                                                                                                                                                                                                                                                                                            ((case (Seq.empty) of
                                                                                                                                                                                                                                                                                              { _lhsOchrClassDeclSq | _lhsOchrClassDeclSq `seq` (True) ->
                                                                                                                                                                                                                                                                                              (case (Seq.empty) of
                                                                                                                                                                                                                                                                                               { _lhsOchrInstDeclSq | _lhsOchrInstDeclSq `seq` (True) ->
                                                                                                                                                                                                                                                                                               (case (emptyGam) of
                                                                                                                                                                                                                                                                                                { _lhsOgathClDfGam | _lhsOgathClDfGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                (case ((let sem_Decls_Nil_12 :: T_Decls_12
                                                                                                                                                                                                                                                                                                            sem_Decls_Nil_12 =
                                                                                                                                                                                                                                                                                                                (\ _lhsIpatTyVarMp
                                                                                                                                                                                                                                                                                                                   _lhsIpatValGam
                                                                                                                                                                                                                                                                                                                   _lhsItvKiVarMp
                                                                                                                                                                                                                                                                                                                   _lhsItySigGam
                                                                                                                                                                                                                                                                                                                   _lhsItySigVarMp ->
                                                                                                                                                                                                                                                                                                                     _lhsIpatTyVarMp `seq`
                                                                                                                                                                                                                                                                                                                     (_lhsIpatValGam `seq`
                                                                                                                                                                                                                                                                                                                      (_lhsItvKiVarMp `seq`
                                                                                                                                                                                                                                                                                                                       (_lhsItySigGam `seq`
                                                                                                                                                                                                                                                                                                                        (_lhsItySigVarMp `seq`
                                                                                                                                                                                                                                                                                                                         ((case (_lhsIpatTyVarMp) of
                                                                                                                                                                                                                                                                                                                           { _lhsOpatTyVarMp | _lhsOpatTyVarMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                           (case (_lhsIpatValGam) of
                                                                                                                                                                                                                                                                                                                            { _lhsOpatValGam | _lhsOpatValGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                            (case ((let sem_Decls_Nil_13 :: T_Decls_13
                                                                                                                                                                                                                                                                                                                                        sem_Decls_Nil_13 =
                                                                                                                                                                                                                                                                                                                                            (\ _lhsIchrStore
                                                                                                                                                                                                                                                                                                                                               _lhsIclDfGam
                                                                                                                                                                                                                                                                                                                                               _lhsItyTyGlobFreeTvarS
                                                                                                                                                                                                                                                                                                                                               _lhsItyVarMp
                                                                                                                                                                                                                                                                                                                                               _lhsIvalGam
                                                                                                                                                                                                                                                                                                                                               _lhsIvalTyGlobFreeTvarS ->
                                                                                                                                                                                                                                                                                                                                                 _lhsIchrStore `seq`
                                                                                                                                                                                                                                                                                                                                                 (_lhsIclDfGam `seq`
                                                                                                                                                                                                                                                                                                                                                  (_lhsItyTyGlobFreeTvarS `seq`
                                                                                                                                                                                                                                                                                                                                                   (_lhsItyVarMp `seq`
                                                                                                                                                                                                                                                                                                                                                    (_lhsIvalGam `seq`
                                                                                                                                                                                                                                                                                                                                                     (_lhsIvalTyGlobFreeTvarS `seq`
                                                                                                                                                                                                                                                                                                                                                      ((case (Map.empty) of
                                                                                                                                                                                                                                                                                                                                                        { _lhsOgathCnstrMp | _lhsOgathCnstrMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                        (case (Map.empty) of
                                                                                                                                                                                                                                                                                                                                                         { _lhsOgathRangeMp | _lhsOgathRangeMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                         (case (emptyGam) of
                                                                                                                                                                                                                                                                                                                                                          { _lhsOintlTyKiGam | _lhsOintlTyKiGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                          (case (Set.empty) of
                                                                                                                                                                                                                                                                                                                                                           { _lhsOnoLetQuantTyVarIdS | _lhsOnoLetQuantTyVarIdS `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                           (case (emptyGam) of
                                                                                                                                                                                                                                                                                                                                                            { _lhsOscopeGam | _lhsOscopeGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                            (case (_lhsItyVarMp) of
                                                                                                                                                                                                                                                                                                                                                             { _lhsOtyVarMp | _lhsOtyVarMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                             (case ((let sem_Decls_Nil_14 :: T_Decls_14
                                                                                                                                                                                                                                                                                                                                                                         sem_Decls_Nil_14 =
                                                                                                                                                                                                                                                                                                                                                                             (\ _lhsIcSubst
                                                                                                                                                                                                                                                                                                                                                                                _lhsIchrEvidBindMp
                                                                                                                                                                                                                                                                                                                                                                                _lhsIchrScopeBindMp
                                                                                                                                                                                                                                                                                                                                                                                _lhsIfinTyVarMp
                                                                                                                                                                                                                                                                                                                                                                                _lhsIfinValGam
                                                                                                                                                                                                                                                                                                                                                                                _lhsIisStrict
                                                                                                                                                                                                                                                                                                                                                                                _lhsIkiSigGam
                                                                                                                                                                                                                                                                                                                                                                                _lhsImoduleNm
                                                                                                                                                                                                                                                                                                                                                                                _lhsIrangeMp
                                                                                                                                                                                                                                                                                                                                                                                _lhsIsysfEnv
                                                                                                                                                                                                                                                                                                                                                                                _lhsItr ->
                                                                                                                                                                                                                                                                                                                                                                                  _lhsIcSubst `seq`
                                                                                                                                                                                                                                                                                                                                                                                  (_lhsIchrEvidBindMp `seq`
                                                                                                                                                                                                                                                                                                                                                                                   (_lhsIchrScopeBindMp `seq`
                                                                                                                                                                                                                                                                                                                                                                                    (_lhsIfinTyVarMp `seq`
                                                                                                                                                                                                                                                                                                                                                                                     (_lhsIfinValGam `seq`
                                                                                                                                                                                                                                                                                                                                                                                      (_lhsIisStrict `seq`
                                                                                                                                                                                                                                                                                                                                                                                       (_lhsIkiSigGam `seq`
                                                                                                                                                                                                                                                                                                                                                                                        (_lhsImoduleNm `seq`
                                                                                                                                                                                                                                                                                                                                                                                         (_lhsIrangeMp `seq`
                                                                                                                                                                                                                                                                                                                                                                                          (_lhsIsysfEnv `seq`
                                                                                                                                                                                                                                                                                                                                                                                           (_lhsItr `seq`
                                                                                                                                                                                                                                                                                                                                                                                            ((case (Seq.empty) of
                                                                                                                                                                                                                                                                                                                                                                                              { _lhsOallErrSq | _lhsOallErrSq `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                              (case ([]) of
                                                                                                                                                                                                                                                                                                                                                                                               { _lhsObangEvalL | _lhsObangEvalL `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                               (case (_lhsIcSubst) of
                                                                                                                                                                                                                                                                                                                                                                                                { _lhsOcSubst | _lhsOcSubst `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                (case (Seq.empty) of
                                                                                                                                                                                                                                                                                                                                                                                                 { _lhsOerrSq | _lhsOerrSq `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                 (case ([]) of
                                                                                                                                                                                                                                                                                                                                                                                                  { _lhsOffeCBindL | _lhsOffeCBindL `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                  (case ([]) of
                                                                                                                                                                                                                                                                                                                                                                                                   { _lhsOffiCBindL | _lhsOffiCBindL `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                   (case (Seq.empty) of
                                                                                                                                                                                                                                                                                                                                                                                                    { _lhsOgathHiddenExports | _lhsOgathHiddenExports `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                    (case (Map.empty) of
                                                                                                                                                                                                                                                                                                                                                                                                     { _lhsOgathLamMp | _lhsOgathLamMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                     (case (Map.empty) of
                                                                                                                                                                                                                                                                                                                                                                                                      { _lhsOgathMentrelFilterMp | _lhsOgathMentrelFilterMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                      (case (emptyVarMp) of
                                                                                                                                                                                                                                                                                                                                                                                                       { _lhsOgathTvKiVarMp | _lhsOgathTvKiVarMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                       (case (Set.empty) of
                                                                                                                                                                                                                                                                                                                                                                                                        { _lhsOorphanS | _lhsOorphanS `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                        (case (empty) of
                                                                                                                                                                                                                                                                                                                                                                                                         { _lhsOpp | _lhsOpp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                         (case (trppEmpty) of
                                                                                                                                                                                                                                                                                                                                                                                                          { _trppHere | _trppHere `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                          (case (ppNestTrPP _lhsIopts ["Decls","Nil"] [] [] _trppHere) of
                                                                                                                                                                                                                                                                                                                                                                                                           { _lhsOppAST | _lhsOppAST `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                           (case (trppEmpty) of
                                                                                                                                                                                                                                                                                                                                                                                                            { _lhsOtrpp | _lhsOtrpp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                            (case ([]) of
                                                                                                                                                                                                                                                                                                                                                                                                             { _lhsOtyCBindL | _lhsOtyCBindL `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                             (case ([]) of
                                                                                                                                                                                                                                                                                                                                                                                                              { _lhsOvalCBindL | _lhsOvalCBindL `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                              ( _lhsOallErrSq,_lhsObangEvalL,_lhsOcSubst,_lhsOerrSq,_lhsOffeCBindL,_lhsOffiCBindL,_lhsOgathHiddenExports,_lhsOgathLamMp,_lhsOgathMentrelFilterMp,_lhsOgathTvKiVarMp,_lhsOorphanS,_lhsOpp,_lhsOppAST,_lhsOtrpp,_lhsOtyCBindL,_lhsOvalCBindL) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) })))))))))))))
                                                                                                                                                                                                                                                                                                                                                                     in  sem_Decls_Nil_14)) of
                                                                                                                                                                                                                                                                                                                                                              { ( sem_Decls_14) | True ->
                                                                                                                                                                                                                                                                                                                                                              ( _lhsOgathCnstrMp,_lhsOgathRangeMp,_lhsOintlTyKiGam,_lhsOnoLetQuantTyVarIdS,_lhsOscopeGam,_lhsOtyVarMp,sem_Decls_14) }) }) }) }) }) }) }))))))))
                                                                                                                                                                                                                                                                                                                                    in  sem_Decls_Nil_13)) of
                                                                                                                                                                                                                                                                                                                             { ( sem_Decls_13) | True ->
                                                                                                                                                                                                                                                                                                                             ( _lhsOpatTyVarMp,_lhsOpatValGam,sem_Decls_13) }) }) })))))))
                                                                                                                                                                                                                                                                                                        in  sem_Decls_Nil_12)) of
                                                                                                                                                                                                                                                                                                 { ( sem_Decls_12) | True ->
                                                                                                                                                                                                                                                                                                 ( _lhsOchrClassDeclSq,_lhsOchrInstDeclSq,_lhsOgathClDfGam,sem_Decls_12) }) }) }) })))
                                                                                                                                                                                                                                                                               in  sem_Decls_Nil_11)) of
                                                                                                                                                                                                                                                                        { ( sem_Decls_11) | True ->
                                                                                                                                                                                                                                                                        ( _lhsOgathDataGam,_lhsOgathDeclDataGam,_lhsOgathTySigGam,_lhsOgathTySigVarMp,sem_Decls_11) }) }) }) }) }))))
                                                                                                                                                                                                                                                    in  sem_Decls_Nil_10)) of
                                                                                                                                                                                                                                             { ( sem_Decls_10) | True ->
                                                                                                                                                                                                                                             ( _lhsOpatClGam2,sem_Decls_10) }) }))))))
                                                                                                                                                                                                                          in  sem_Decls_Nil_9)) of
                                                                                                                                                                                                                   { ( sem_Decls_9) | True ->
                                                                                                                                                                                                                   ( _lhsOpatClGam1,sem_Decls_9) }) })))
                                                                                                                                                                                                   in  sem_Decls_Nil_8)) of
                                                                                                                                                                                            { ( sem_Decls_8) | True ->
                                                                                                                                                                                            ( _lhsOgenerDataInfoL,_lhsOgenerDataInfoMp,_lhsOkiVarMp,_lhsOpolVarMp,sem_Decls_8) }) }) }) }) }))))))))))
                                                                                                                                                                  in  sem_Decls_Nil_7)) of
                                                                                                                                                           { ( sem_Decls_7) | True ->
                                                                                                                                                           ( _lhsOpatKiVarMp,_lhsOpatPolGam,sem_Decls_7) }) }) })))))
                                                                                                                                        in  sem_Decls_Nil_6)) of
                                                                                                                                 { ( sem_Decls_6) | True ->
                                                                                                                                 ( _lhsOpatTyKiGam,_lhsOtyTyVarMp,sem_Decls_6) }) }) })))))
                                                                                                              in  sem_Decls_Nil_5)) of
                                                                                                       { ( sem_Decls_5) | True ->
                                                                                                       ( _lhsOpatTyGam,sem_Decls_5) }) }))))
                                                                                      in  sem_Decls_Nil_4)) of
                                                                               { ( sem_Decls_4) | True ->
                                                                               ( _lhsOpredSameScopeCounter,sem_Decls_4) }) }))))
                                                              in  sem_Decls_Nil_3)) of
                                                       { ( sem_Decls_3) | True ->
                                                       ( _lhsOgathTyKiSigGam,sem_Decls_3) }) })))
                                       in  sem_Decls_Nil_2)) of
                                { ( sem_Decls_2) | True ->
                                ( _lhsOgUniq,_lhsOgathKiSigGam,_lhsOhasInstDecl,sem_Decls_2) }) }) }) }))))
             in  sem_Decls_Nil_1)) of
      { ( sem_Decls_1) | True ->
      ( _lhsOrange,sem_Decls_1) }) })