packages feed

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



module UHC.Light.Compiler.EH.MainAG_Decl 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

-- Decl --------------------------------------------------------
{-
   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 TySig:
         child hsrange        : {Range}
         child nm             : {HsName}
         child tyExpr         : TyExpr 
         visit 0:
            local range       : {Range}
         visit 1:
            local _tup23      : _
            intra range       : {Range}
         visit 2:
            intra _tup23      : _
            intra range       : {Range}
         visit 3:
            intra _tup23      : _
            intra range       : {Range}
         visit 4:
            intra _tup23      : _
            intra range       : {Range}
         visit 5:
            intra _tup23      : _
            intra range       : {Range}
         visit 6:
            intra _tup23      : _
            intra range       : {Range}
         visit 7:
            local lUniq_17_polCtx : {UID}
            local lUniq2      : {UID}
            local polCtxVar   : {Polarity}
            local fo_         : {FIOut}
            intra _tup23      : _
            intra range       : {Range}
         visit 8:
            intra _tup23      : _
            intra fo_         : {FIOut}
            intra range       : {Range}
         visit 9:
            intra _tup23      : _
            intra fo_         : {FIOut}
            intra range       : {Range}
         visit 10:
            local lUniq_sig   : {UID}
            local tyTyUpdFreeTvarS : _
            local gTyTvS      : {TyVarIdS}
            local ty_sig_     : {Ty}
            local gamSigTy    : _
            local _tup22      : _
            local gathTySigGam : _
            local gathTySigVarMp : _
            intra _tup23      : _
            intra fo_         : {FIOut}
            intra range       : {Range}
         visit 11:
            intra fo_         : {FIOut}
            intra range       : {Range}
         visit 12:
            intra fo_         : {FIOut}
            intra range       : {Range}
         visit 13:
            intra fo_         : {FIOut}
            intra range       : {Range}
         visit 14:
            local tyPP        : _
            local pp          : _
            local trppHere    : _
            intra fo_         : {FIOut}
            intra range       : {Range}
      alternative Val:
         child hsrange        : {Range}
         child patExpr        : PatExpr 
         child expr           : Expr 
         visit 0:
            local range       : {Range}
         visit 1:
            local _tup26      : _
            intra range       : {Range}
         visit 2:
            intra range       : {Range}
         visit 3:
            intra range       : {Range}
         visit 4:
            intra range       : {Range}
         visit 5:
            intra range       : {Range}
         visit 6:
            intra range       : {Range}
         visit 7:
            local predScope   : {PredScope}
            intra range       : {Range}
         visit 8:
            intra predScope   : {PredScope}
            intra range       : {Range}
         visit 9:
            intra predScope   : {PredScope}
            intra range       : {Range}
         visit 10:
            intra predScope   : {PredScope}
            intra range       : {Range}
         visit 11:
            intra predScope   : {PredScope}
            intra range       : {Range}
         visit 12:
            local _tup25      : _
            local ty_sig_     : {Ty}
            local knTy        : {Ty}
            local hasTySig    : {Bool}
            intra predScope   : {PredScope}
            intra range       : {Range}
         visit 13:
            local exprKnTy    : {Ty}
            intra knTy        : {Ty}
            intra hasTySig    : {Bool}
            intra predScope   : {PredScope}
            intra range       : {Range}
         visit 14:
            local _tup24      : _
            local chrScopeBindMp : _
            local finalTy     : _
            local fe          : {FIEnv}
            local finalTyExpanded : _
            local sysfty      : _
            local acorety     : _
            local pp          : _
            local trppHere    : _
            local chrScopeValBindL : _
            intra predScope   : {PredScope}
            intra range       : {Range}
      alternative Data:
         child hsrange        : {Range}
         child isNewtype      : {Bool}
         child tyNm           : {HsName}
         child tyVars         : TyVars 
         child constrs        : DataConstrs 
         child mbGenerInfo    : {Maybe Int}
         visit 0:
            local range       : {Range}
         visit 1:
            local _tup29      : _
            intra range       : {Range}
         visit 2:
            intra _tup29      : _
            intra range       : {Range}
         visit 3:
            intra _tup29      : _
            intra range       : {Range}
         visit 4:
            local _tup28      : _
            local hasKiSig    : {Bool}
            local extraTyGam  : _
            local dataTgi     : _
            local dataPatTyGam : _
            intra _tup29      : _
            intra range       : {Range}
         visit 5:
            local lUniq       : {UID}
            local sigKi       : {Ty}
            local knKi        : {Ty}
            local extraTyKiGam : _
            local dataTkgi    : {TyKiGamInfo}
            local dataPatTyKiGam : _
            intra _tup29      : _
            intra _tup28      : _
            intra hasKiSig    : {Bool}
            intra range       : {Range}
         visit 6:
            local lUniq2      : {UID}
            local fo_         : {FIOut}
            local lUniq_17_polCtx : {UID}
            local polCtxVar   : {Polarity}
            local polSig      : {Polarity}
            intra _tup29      : _
            intra dataTkgi    : {TyKiGamInfo}
            intra range       : {Range}
         visit 7:
            local dataTy      : {Ty}
            local dataAltTy   : {Ty}
            local dataTyVarIdL : {[TyVarId]}
            local dataKi      : {Ty}
            local lUniq3      : {UID}
            local _tup27      : _
            local generDataInfoL : _
            local generDataInfoMpNew : _
            intra polCtxVar   : {Polarity}
            intra fo_         : {FIOut}
            intra _tup29      : _
            intra dataTkgi    : {TyKiGamInfo}
            intra range       : {Range}
         visit 8:
            intra dataTyVarIdL : {[TyVarId]}
            intra dataTkgi    : {TyKiGamInfo}
            intra dataAltTy   : {Ty}
            intra dataTy      : {Ty}
            intra range       : {Range}
            intra fo_         : {FIOut}
         visit 9:
            intra dataTyVarIdL : {[TyVarId]}
            intra dataTkgi    : {TyKiGamInfo}
            intra dataAltTy   : {Ty}
            intra dataTy      : {Ty}
            intra range       : {Range}
            intra fo_         : {FIOut}
         visit 10:
            local extraDataGam : _
            local dgi         : {DataGamInfo}
            intra dataTyVarIdL : {[TyVarId]}
            intra dataTkgi    : {TyKiGamInfo}
            intra dataAltTy   : {Ty}
            intra dataTy      : {Ty}
            intra range       : {Range}
            intra fo_         : {FIOut}
         visit 11:
            intra range       : {Range}
            intra fo_         : {FIOut}
            intra dgi         : {DataGamInfo}
         visit 12:
            intra range       : {Range}
            intra fo_         : {FIOut}
            intra dgi         : {DataGamInfo}
         visit 13:
            intra range       : {Range}
            intra fo_         : {FIOut}
            intra dgi         : {DataGamInfo}
         visit 14:
            local fe          : {FIEnv}
            local inconsistFldErrs : _
            local pp          : _
            local trppHere    : _
            local rceEnv      : _
            local fldSelCBindL : _
            intra range       : {Range}
            intra fo_         : {FIOut}
            intra dgi         : {DataGamInfo}
      alternative KiSig:
         child hsrange        : {Range}
         child nm             : {HsName}
         child kiExpr         : KiExpr 
         visit 0:
            local range       : {Range}
         visit 2:
            local sigKi       : {Ty}
         visit 14:
            local pp          : _
      alternative FFI:
         child hsrange        : {Range}
         child callconv       : {FFIWay}
         child safety         : {String}
         child impEnt         : {ForeignEnt}
         child nm             : {HsName}
         child tyExpr         : TyExpr 
         visit 0:
            local range       : {Range}
         visit 1:
            local _tup30      : _
            intra range       : {Range}
         visit 2:
            intra _tup30      : _
            intra range       : {Range}
         visit 3:
            intra _tup30      : _
            intra range       : {Range}
         visit 4:
            intra _tup30      : _
            intra range       : {Range}
         visit 5:
            intra _tup30      : _
            intra range       : {Range}
         visit 6:
            intra _tup30      : _
            intra range       : {Range}
         visit 7:
            intra _tup30      : _
            intra range       : {Range}
         visit 8:
            intra _tup30      : _
            intra range       : {Range}
         visit 9:
            intra _tup30      : _
            intra range       : {Range}
         visit 10:
            local ty_sig_     : {Ty}
            intra _tup30      : _
            intra range       : {Range}
         visit 11:
            intra _tup30      : _
            intra range       : {Range}
            intra ty_sig_     : {Ty}
         visit 12:
            intra _tup30      : _
            intra range       : {Range}
            intra ty_sig_     : {Ty}
         visit 13:
            intra _tup30      : _
            intra range       : {Range}
            intra ty_sig_     : {Ty}
         visit 14:
            local lUniq3      : {UID}
            local lUniq2      : {UID}
            local lUniq       : {UID}
            local foreignEntInfo : {ForeignExtraction}
            local knTy        : {Ty}
            local fe          : {FIEnv}
            local foFFI       : _
            local pp          : _
            local lUniqFFI    : {UID}
            local rceEnv      : _
            local finalTyExpanded : _
            local sysfty      : _
            local acorety     : _
            local trppHere    : _
            local ppAST       : _
            intra _tup30      : _
            intra range       : {Range}
            intra ty_sig_     : {Ty}
      alternative Type:
         child hsrange        : {Range}
         child tyNm           : {HsName}
         child tyExpr         : TyExpr 
         visit 0:
            local range       : {Range}
         visit 1:
            local _tup33      : _
            intra range       : {Range}
         visit 2:
            intra _tup33      : _
            intra range       : {Range}
         visit 3:
            intra _tup33      : _
            intra range       : {Range}
         visit 4:
            local lUniq       : {UID}
            local typeVar     : _
            local typeTgi     : {TyGamInfo}
            intra _tup33      : _
            intra range       : {Range}
         visit 5:
            local _tup32      : _
            local sigKi       : {Ty}
            local knKi        : {Ty}
            local typeTkgi    : {TyKiGamInfo}
            local lUniq2      : {UID}
            local foTy_       : _
            intra lUniq       : {UID}
            intra _tup33      : _
            intra typeTgi     : {TyGamInfo}
            intra range       : {Range}
         visit 6:
            local lUniq_17_seed_pol : {UID}
            local _tup31      : _
            local polTypeVar  : {Polarity}
            local polSig      : {Polarity}
            intra _tup33      : _
            intra typeTkgi    : {TyKiGamInfo}
            intra lUniq2      : {UID}
            intra range       : {Range}
         visit 7:
            local polCtxVar   : {Polarity}
            local foKi_       : {FIOut}
            local lUniq_17_fitsIn_pol : {UID}
            local foPol       : {FIOut}
            intra _tup31      : _
            intra typeTkgi    : {TyKiGamInfo}
            intra lUniq2      : {UID}
            intra _tup33      : _
            intra polSig      : {Polarity}
            intra range       : {Range}
         visit 8:
            intra foPol       : {FIOut}
            intra foKi_       : {FIOut}
            intra range       : {Range}
         visit 9:
            intra foPol       : {FIOut}
            intra foKi_       : {FIOut}
            intra range       : {Range}
         visit 10:
            intra foPol       : {FIOut}
            intra foKi_       : {FIOut}
            intra range       : {Range}
         visit 11:
            intra foPol       : {FIOut}
            intra foKi_       : {FIOut}
            intra range       : {Range}
         visit 12:
            intra foPol       : {FIOut}
            intra foKi_       : {FIOut}
            intra range       : {Range}
         visit 13:
            intra foPol       : {FIOut}
            intra foKi_       : {FIOut}
            intra range       : {Range}
         visit 14:
            local pp          : _
            intra foPol       : {FIOut}
            intra foKi_       : {FIOut}
            intra range       : {Range}
      alternative FFE:
         child hsrange        : {Range}
         child nm             : {HsName}
         child callconv       : {FFIWay}
         child expEnt         : {ForeignEnt}
         child expr           : Expr 
         child tyExpr         : TyExpr 
         visit 0:
            local range       : {Range}
         visit 1:
            local _tup35      : _
            intra range       : {Range}
         visit 2:
            intra _tup35      : _
            intra range       : {Range}
         visit 3:
            intra _tup35      : _
            intra range       : {Range}
         visit 4:
            intra _tup35      : _
            intra range       : {Range}
         visit 5:
            intra _tup35      : _
            intra range       : {Range}
         visit 6:
            intra _tup35      : _
            intra range       : {Range}
         visit 7:
            intra _tup35      : _
            intra range       : {Range}
         visit 8:
            intra _tup35      : _
            intra range       : {Range}
         visit 9:
            intra _tup35      : _
            intra range       : {Range}
         visit 10:
            local ty_sig_     : {Ty}
            intra _tup35      : _
            intra range       : {Range}
         visit 11:
            intra ty_sig_     : {Ty}
            intra _tup35      : _
            intra range       : {Range}
         visit 12:
            intra ty_sig_     : {Ty}
            intra _tup35      : _
            intra range       : {Range}
         visit 13:
            local knTy        : {Ty}
            local exprFiOpts  : {FIOpts}
            intra ty_sig_     : {Ty}
            intra _tup35      : _
            intra range       : {Range}
         visit 14:
            local lUniqFFE    : {UID}
            local rceEnv      : _
            local fe          : {FIEnv}
            local finalTyExpanded : _
            local _tup34      : _
            local ffeMkCExpr  : _
            local ffeCExpr    : _
            local ffeTy       : _
            local gathMentrelFilterMp : _
            local pp          : _
            local trppHere    : _
            local ppAST       : _
            intra _tup35      : _
            intra range       : {Range}
            intra ty_sig_     : {Ty}
      alternative GenerRep:
         child hsrange        : {Range}
         child maxArity       : {Int}
         child arity          : {Int}
         child tyNm           : {HsName}
         child conNmL         : {[HsName]}
         child recFldNmL      : {[(HsName,[HsName])]}
         visit 0:
            local range       : {Range}
         visit 1:
            intra range       : {Range}
         visit 2:
            intra range       : {Range}
         visit 3:
            intra range       : {Range}
         visit 4:
            intra range       : {Range}
         visit 5:
            intra range       : {Range}
         visit 6:
            intra range       : {Range}
         visit 7:
            local _tup36      : _
            local generDataInfoL : _
            intra range       : {Range}
         visit 8:
            intra _tup36      : _
            intra range       : {Range}
         visit 9:
            intra _tup36      : _
            intra range       : {Range}
         visit 10:
            intra _tup36      : _
            intra range       : {Range}
         visit 11:
            intra _tup36      : _
            intra range       : {Range}
         visit 12:
            intra _tup36      : _
            intra range       : {Range}
         visit 13:
            intra _tup36      : _
            intra range       : {Range}
         visit 14:
            local pp          : _
            local errsNoIntroNm : _
            intra _tup36      : _
            intra range       : {Range}
      alternative FusionDecl:
         child hsrange        : {Range}
         child fuseNm         : {HsName}
         visit 0:
            local range       : {Range}
         visit 14:
            local pp          : _
      alternative FusionConv:
         child hsrange        : {Range}
         child conNm          : {HsName}
         child absNm          : {HsName}
         visit 0:
            local range       : {Range}
         visit 1:
            local _tup37      : _
            intra range       : {Range}
         visit 2:
            intra _tup37      : _
            intra range       : {Range}
         visit 3:
            intra _tup37      : _
            intra range       : {Range}
         visit 4:
            intra _tup37      : _
            intra range       : {Range}
         visit 5:
            intra _tup37      : _
            intra range       : {Range}
         visit 6:
            intra _tup37      : _
            intra range       : {Range}
         visit 7:
            intra _tup37      : _
            intra range       : {Range}
         visit 8:
            intra _tup37      : _
            intra range       : {Range}
         visit 9:
            intra _tup37      : _
            intra range       : {Range}
         visit 10:
            intra _tup37      : _
            intra range       : {Range}
         visit 11:
            intra _tup37      : _
            intra range       : {Range}
         visit 12:
            intra _tup37      : _
            intra range       : {Range}
         visit 13:
            intra _tup37      : _
            intra range       : {Range}
         visit 14:
            local lUniq_buildInverse : {UID}
            local finAbsTy    : _
            local finConTy    : _
            local fe          : {FIEnv}
            local foBuildInverse : _
            local pp          : _
            intra _tup37      : _
            intra range       : {Range}
      alternative Class:
         child hsrange        : {Range}
         child clNm           : {HsName}
         child tyPrExpr       : TyExpr 
         child funcDeps       : FuncDeps 
         child mbDefaultInstNm : {Maybe HsName}
         child decls          : Decls 
         child generDerivs    : {[(HsName,HsName)]}
         visit 0:
            local range       : {Range}
         visit 1:
            local _tup41      : _
         visit 2:
            intra _tup41      : _
         visit 3:
            intra _tup41      : _
         visit 4:
            local dataDictNm  : {HsName}
            intra _tup41      : _
         visit 5:
            local lUniq       : {UID}
            local clsKiVar    : _
            intra _tup41      : _
            intra dataDictNm  : {HsName}
         visit 6:
            local lUniq_17_polCtx : {UID}
            local _tup38      : _
            local hdPrTy      : {Ty}
            local _tup39      : _
            local prClsNm     : {HsName}
            local polCtxVar   : {Polarity}
            local polSig      : {Polarity}
            intra _tup41      : _
            intra lUniq       : {UID}
            intra dataDictNm  : {HsName}
            intra clsKiVar    : _
         visit 7:
            local predScope   : {PredScope}
            intra polCtxVar   : {Polarity}
            intra lUniq       : {UID}
            intra hdPrTy      : {Ty}
            intra _tup38      : _
            intra dataDictNm  : {HsName}
            intra clsKiVar    : _
         visit 8:
            local clgi1       : {ClGamInfo}
            intra lUniq       : {UID}
            intra hdPrTy      : {Ty}
            intra _tup38      : _
            intra dataDictNm  : {HsName}
            intra clsKiVar    : _
         visit 9:
            local lSigGam     : _
            local clsTySigGam : {ValGam}
            local clsTySigDictGam : _
            local clsFldTyL   : _
            local ctxtPrTyL   : {TyL}
            local supClsFldTyL : _
            local clsAllFldTyL : _
            local dataDictTag : {CTag}
            local dictTag     : {CTag}
            local dataDictTy  : _
            local clsTyRec    : {Ty}
            local clgiUpd     : _
            intra hdPrTy      : {Ty}
            intra _tup38      : _
            intra dataDictNm  : {HsName}
            intra clsKiVar    : _
            intra clgi1       : {ClGamInfo}
         visit 10:
            local _tup40      : _
            local dataDictConTy : _
            intra dataDictTy  : _
            intra clsAllFldTyL : _
            intra dataDictNm  : {HsName}
            intra dataDictTag : {CTag}
            intra clsTyRec    : {Ty}
            intra clsKiVar    : _
            intra clsTySigGam : {ValGam}
            intra supClsFldTyL : _
            intra ctxtPrTyL   : {TyL}
            intra dictTag     : {CTag}
            intra hdPrTy      : {Ty}
            intra clgi1       : {ClGamInfo}
            intra clgiUpd     : _
            intra clsFldTyL   : _
         visit 11:
            local supClsFldNmL : {[HsName]}
            local chrClassDecl : _
            intra supClsFldTyL : _
            intra ctxtPrTyL   : {TyL}
            intra dictTag     : {CTag}
            intra hdPrTy      : {Ty}
            intra clsTyRec    : {Ty}
            intra _tup40      : _
            intra dataDictTy  : _
            intra dataDictConTy : _
            intra dataDictNm  : {HsName}
            intra clgi1       : {ClGamInfo}
            intra clgiUpd     : _
            intra clsFldTyL   : _
         visit 12:
            local dataDictConProdTy : _
            local dataDictQuUnConTy : _
            intra _tup40      : _
            intra dataDictTy  : _
            intra dataDictConTy : _
            intra dataDictNm  : {HsName}
            intra hdPrTy      : {Ty}
            intra clgi1       : {ClGamInfo}
            intra clgiUpd     : _
            intra clsFldTyL   : _
            intra clsTyRec    : {Ty}
            intra dictTag     : {CTag}
         visit 13:
            intra hdPrTy      : {Ty}
            intra clgi1       : {ClGamInfo}
            intra clgiUpd     : _
            intra clsFldTyL   : _
            intra dataDictTy  : _
            intra clsTyRec    : {Ty}
            intra dictTag     : {CTag}
         visit 14:
            local clsTyArgs   : _
            local pp          : _
            local clgi2       : {ClGamInfo}
            local trppHere    : _
            local ppAST       : _
            local trpp        : _
            intra hdPrTy      : {Ty}
            intra clgi1       : {ClGamInfo}
            intra clgiUpd     : _
            intra clsFldTyL   : _
            intra dataDictTy  : _
            intra clsTyRec    : {Ty}
            intra dictTag     : {CTag}
      alternative Instance:
         child hsrange        : {Range}
         child mbNmElim       : {Maybe (HsName,Bool)}
         child instVariant    : {InstVariant}
         child tyPrExpr       : TyExpr 
         child decls          : Decls 
         visit 0:
            local range       : {Range}
         visit 1:
            local _tup58      : _
            intra range       : {Range}
         visit 2:
            intra _tup58      : _
            intra range       : {Range}
         visit 3:
            intra _tup58      : _
            intra range       : {Range}
         visit 4:
            intra _tup58      : _
            intra range       : {Range}
         visit 5:
            intra _tup58      : _
            intra range       : {Range}
         visit 6:
            intra _tup58      : _
            intra range       : {Range}
         visit 7:
            local lUniq_17_polCtx : {UID}
            local predScope   : {PredScope}
            local mbKnPolCtx  : _
            intra _tup58      : _
            intra range       : {Range}
         visit 8:
            intra _tup58      : _
            intra range       : {Range}
            intra predScope   : {PredScope}
         visit 9:
            intra _tup58      : _
            intra range       : {Range}
            intra predScope   : {PredScope}
         visit 10:
            intra _tup58      : _
            intra range       : {Range}
            intra predScope   : {PredScope}
         visit 11:
            local lUniq_9_prTyFix : {UID}
            local lUniq       : {UID}
            local instId      : _
            local _tup54      : _
            local inclForElim : _
            local dictNm      : {HsName}
            local _tup51      : _
            local prTyFix     : {Ty}
            local _tup52      : _
            local hdPrTyFix   : {Ty}
            local ctxtPrTyFixL : {[Ty]}
            local unfixPrTyVarMp : {VarMp}
            local chrInstDecl : _
            intra _tup58      : _
            intra range       : {Range}
            intra predScope   : {PredScope}
         visit 12:
            local _tup53      : _
            local instClsNm   : _
            local dataDictNm  : {HsName}
            local instArgTyL  : _
            local dataDictTy  : _
            local ctxtPrFixL  : _
            local vgi         : _
            intra hdPrTyFix   : {Ty}
            intra ctxtPrTyFixL : {[Ty]}
            intra unfixPrTyVarMp : {VarMp}
            intra dictNm      : {HsName}
            intra _tup51      : _
            intra _tup58      : _
            intra range       : {Range}
            intra _tup52      : _
            intra predScope   : {PredScope}
            intra lUniq       : {UID}
         visit 13:
            local fixPrTyVarMp : {VarMp}
            local recTy       : {Ty}
            local recTyExts   : {AssocL HsName Ty}
            local tySigGam    : {ValGam}
            intra _tup51      : _
            intra _tup58      : _
            intra range       : {Range}
            intra instClsNm   : _
            intra _tup52      : _
            intra predScope   : {PredScope}
            intra hdPrTyFix   : {Ty}
            intra dictNm      : {HsName}
            intra ctxtPrFixL  : _
            intra dataDictNm  : {HsName}
            intra lUniq       : {UID}
            intra instArgTyL  : _
         visit 14:
            local lUniq_generDeriv2 : {UID}
            local lUniq_generDeriv1 : {UID}
            local lUniq_95_fitsIn_dataTy : {UID}
            local lUniq_95_extraPrOcc : {UID}
            local lUniq_95_altsPrOcc : {UID}
            local lUniq7      : {UID}
            local lUniq6      : {UID}
            local lUniq5      : {UID}
            local lUniq4      : {UID}
            local lUniq3      : {UID}
            local fe          : {FIEnv}
            local derivIsIx   : _
            local derivIsBounded : _
            local derivIsEnum : _
            local derivDataTGI : {TyGamInfo}
            local mbDerivDataCTags : _
            local derivDataHasGt1Constrs : _
            local derivDataHasFlds : _
            local derivMp     : _
            local mbDerivDCL  : _
            local derivDataDGI : {DataGamInfo}
            local derivCanBeDoneBuiltin : _
            local _tup56      : _
            local clgi        : {ClGamInfo}
            local derivTruncTailArity : {Int}
            local derivArity  : {Int}
            local derivDataTyNm : {HsName}
            local derivDataTyArgs : {TyL}
            local generForFitsInL : {[GenerForFitsIn]}
            local _tup42      : _
            local foGenerDeriv : _
            local tyVarMpDeclsL0 : {VarMp}
            local tyVarMpDeclsL01 : {VarMp}
            local doPredAmbigSplitForSimplify : _
            local fe2         : _
            local derivCanBeDoneGeneric : _
            local derivHdDataTy : {Ty}
            local derivErrs   : _
            local supPrTyL    : _
            local _tup55      : _
            local dictSelfNm  : _
            local dictBuildNm : _
            local derivHdPrTyCon : {Ty}
            local chrFIIn     : {FIIn}
            local _tup43      : _
            local chrSuperProveCnstrMp : _
            local chrCtxtAssumeCnstrMp : _
            local toProveSuperCnstrMp : _
            local chrProveFIIn : {FIIn}
            local _tup47      : _
            local chrSolveSuperRemCnstrMp : _
            local foGenerDerivL : _
            local generCnstrMp : _
            local _tup44      : _
            local toProveGathCnstrMp : _
            local chrInstAssumeCnstrMp : _
            local toProveDeclsCnstrMp : _
            local _tup45      : _
            local chrSolveDeclsRemCnstrMp : _
            local toAssumeNeverCnstrMp : _
            local cannotResSuperCnstrMp : _
            local cannotResDeclsCnstrMp : _
            local cannotProveCnstrMp : _
            local predNotPrfErrs : _
            local valNoSigErrs : _
            local clgiNmErrs  : _
            local cxSplitErrs : {ErrL}
            local chrSolveSuperErrs : _
            local chrSolveDeclsErrs : _
            local lErrSq      : _
            local chrSolveDeclsScopeBindMp : _
            local chrScopeBindMp : _
            local chrSolveDeclsEvidBindMp : _
            local chrEvidBindMp : _
            local cSubstDecls : _
            local lUniq_bind  : {UID}
            local rceEnv      : _
            local finalTy     : _
            local dataDictTag : {CTag}
            local dictTag     : {CTag}
            local derivExtraPrOcc : _
            local derivAltsPrOcc : _
            local mkf         : _
            local supClsFldNmL : {[HsName]}
            local chrCtxtArgUIDL : _
            local chrAssumeDeclsCtxtBindL : _
            local chrInstArgUID : _
            local chrAssumeDeclsInstBindL : _
            local chrSolveSuperEvidBindMp : _
            local chrAssumeSuperBindL : _
            local _tup50      : _
            local chrScopeDeclsBindL : _
            local chrSolveSuperScopeBindMp : _
            local _tup49      : _
            local chrScopeSuperBindL : _
            local chrSolveSuperEvidCBindL : _
            local chrSolveDeclsEvidCBindL : _
            local derivDCL    : _
            local chrSuperProveNmL : _
            local chrCtxtArgNmL : _
            local _tup57      : _
            local cSubstInst  : _
            local chrSuperSimplifyResult : _
            local chrDeclsSimplifyResult : _
            local gathMentrelFilterMp : _
            local finalHdInstArgLExpanded : _
            local tyOrphanS   : _
            local clsOrphanS  : _
            local orphanS     : _
            local errDeclsPP  : _
            local errInstPP   : _
            local pp          : _
            local trppHere    : _
            local ppAST       : _
            local trpp        : _
            intra _tup58      : _
            intra range       : {Range}
            intra instClsNm   : _
            intra _tup52      : _
            intra tySigGam    : {ValGam}
            intra predScope   : {PredScope}
            intra hdPrTyFix   : {Ty}
            intra dictNm      : {HsName}
            intra ctxtPrFixL  : _
            intra recTyExts   : {AssocL HsName Ty}
            intra dataDictNm  : {HsName}
            intra lUniq       : {UID}
            intra recTy       : {Ty}
            intra instArgTyL  : _
      alternative InstanceIntro:
         child hsrange        : {Range}
         child mbNmElim       : {Maybe (HsName)}
         child expr           : Expr 
         child prExpr         : PrExpr 
         visit 0:
            local range       : {Range}
         visit 1:
            local _tup60      : _
            intra range       : {Range}
         visit 2:
            intra _tup60      : _
            intra range       : {Range}
         visit 3:
            intra _tup60      : _
            intra range       : {Range}
         visit 4:
            intra _tup60      : _
            intra range       : {Range}
         visit 5:
            intra _tup60      : _
            intra range       : {Range}
         visit 6:
            intra _tup60      : _
            intra range       : {Range}
         visit 7:
            local lUniq_17_polCtx : {UID}
            intra _tup60      : _
            intra range       : {Range}
         visit 8:
            intra _tup60      : _
            intra range       : {Range}
         visit 9:
            intra _tup60      : _
            intra range       : {Range}
         visit 10:
            intra _tup60      : _
            intra range       : {Range}
         visit 11:
            local lUniq_9_prTyMeta : {UID}
            local lUniq       : {UID}
            local instId      : _
            local dictNm      : {HsName}
            local chrInstDecl : _
            intra _tup60      : _
            intra range       : {Range}
         visit 12:
            intra lUniq       : {UID}
            intra range       : {Range}
            intra dictNm      : {HsName}
         visit 13:
            local foPr        : {FIOut}
            intra lUniq       : {UID}
            intra range       : {Range}
            intra dictNm      : {HsName}
         visit 14:
            local predErrs    : _
            local lErrSq      : _
            local errInstPP   : _
            local pp          : _
            local trppHere    : _
            local ppAST       : _
            intra range       : {Range}
            intra foPr        : {FIOut}
            intra dictNm      : {HsName}
      alternative Default:
         child hsrange        : {Range}
         child nm             : {HsName}
         child tyExprs        : TyExprs 
         visit 0:
            local range       : {Range}
         visit 1:
            local _tup61      : _
         visit 2:
            intra _tup61      : _
         visit 3:
            intra _tup61      : _
         visit 4:
            intra _tup61      : _
         visit 5:
            intra _tup61      : _
         visit 6:
            intra _tup61      : _
         visit 7:
            intra _tup61      : _
         visit 8:
            intra _tup61      : _
         visit 9:
            intra _tup61      : _
         visit 10:
            intra _tup61      : _
         visit 11:
            intra _tup61      : _
         visit 12:
            intra _tup61      : _
         visit 13:
            intra _tup61      : _
         visit 14:
            local lUniq_17_polCtx : {UID}
            local gathMentrelFilterMp : _
            local pp          : _
            local trppHere    : _
            local ppAST       : _
            intra _tup61      : _
-}
sem_Decl_TySig :: Range ->
                  HsName ->
                  T_TyExpr ->
                  T_Decl

sem_Decl_TySig hsrange_ nm_ tyExpr_ | hsrange_ `seq` (nm_ `seq` (tyExpr_ `seq` (True))) =
    (case (tyExpr_) of
     { ( _tyExprIrange,tyExpr_1) | True ->
         (case (rangeUnions [hsrange_, _tyExprIrange , _tyExprIrange]) of
          { _range | _range `seq` (True) ->
          (case (_range) of
           { _lhsOrange | _lhsOrange `seq` (True) ->
           (case ((let sem_Decl_TySig_1 :: T_Decl_1
                       sem_Decl_TySig_1 =
                           (\ _lhsIgUniq
                              _lhsIgathKiSigGam ->
                                _lhsIgUniq `seq`
                                (_lhsIgathKiSigGam `seq`
                                 ((case (let __cont = _lhsIgUniq in seq __cont ( case nextUnique __cont of { (__cont, lUniq2) -> case nextUnique __cont of { (__cont, lUniq_17_polCtx) -> case nextUnique __cont of { (__cont, lUniq_sig) -> (__cont,lUniq2,lUniq_17_polCtx,lUniq_sig)}}} )) of
                                   { __tup23 | __tup23 `seq` (True) ->
                                   (case (__tup23) of
                                    { (_tyExprOgUniq,_,_,_) | _tyExprOgUniq `seq` (True) ->
                                    (case (tyExpr_1 _tyExprOgUniq) of
                                     { ( _tyExprIgUniq,tyExpr_2) | True ->
                                         (case (_tyExprIgUniq) of
                                          { _lhsOgUniq | _lhsOgUniq `seq` (True) ->
                                          (case (_lhsIgathKiSigGam) of
                                           { _lhsOgathKiSigGam | _lhsOgathKiSigGam `seq` (True) ->
                                           (case (False) of
                                            { _lhsOhasInstDecl | _lhsOhasInstDecl `seq` (True) ->
                                            (case ((let sem_Decl_TySig_2 :: T_Decl_2
                                                        sem_Decl_TySig_2 =
                                                            (\ _lhsIkiGam ->
                                                                 _lhsIkiGam `seq`
                                                                 ((case (emptyGam) of
                                                                   { _lhsOgathTyKiSigGam | _lhsOgathTyKiSigGam `seq` (True) ->
                                                                   (case ((let sem_Decl_TySig_3 :: T_Decl_3
                                                                               sem_Decl_TySig_3 =
                                                                                   (\ _lhsIlexLev
                                                                                      _lhsIpredSameScopeCounter ->
                                                                                        _lhsIlexLev `seq`
                                                                                        (_lhsIpredSameScopeCounter `seq`
                                                                                         ((case (_lhsIpredSameScopeCounter) of
                                                                                           { _lhsOpredSameScopeCounter | _lhsOpredSameScopeCounter `seq` (True) ->
                                                                                           (case ((let sem_Decl_TySig_4 :: T_Decl_4
                                                                                                       sem_Decl_TySig_4 =
                                                                                                           (\ _lhsIpatTyGam
                                                                                                              _lhsItyKiSigGam ->
                                                                                                                _lhsIpatTyGam `seq`
                                                                                                                (_lhsItyKiSigGam `seq`
                                                                                                                 ((case (_lhsIpatTyGam) of
                                                                                                                   { _lhsOpatTyGam | _lhsOpatTyGam `seq` (True) ->
                                                                                                                   (case ((let sem_Decl_TySig_5 :: T_Decl_5
                                                                                                                               sem_Decl_TySig_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_Decl_TySig_6 :: T_Decl_6
                                                                                                                                                         sem_Decl_TySig_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_Decl_TySig_7 :: T_Decl_7
                                                                                                                                                                                   sem_Decl_TySig_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 (_lhsIpolVarMp) of
                                                                                                                                                                                                       { _tyExprOpolVarMp | _tyExprOpolVarMp `seq` (True) ->
                                                                                                                                                                                                       (case (_lhsIpolGam) of
                                                                                                                                                                                                        { _tyExprOpolGam | _tyExprOpolGam `seq` (True) ->
                                                                                                                                                                                                        (case (_lhsIkiVarMp) of
                                                                                                                                                                                                         { _tyExprOkiVarMp | _tyExprOkiVarMp `seq` (True) ->
                                                                                                                                                                                                         (case (__tup23) of
                                                                                                                                                                                                          { (_,_,_lUniq_17_polCtx,_) | _lUniq_17_polCtx `seq` (True) ->
                                                                                                                                                                                                          (case (__tup23) of
                                                                                                                                                                                                           { (_,_lUniq2,_,_) | _lUniq2 `seq` (True) ->
                                                                                                                                                                                                           (case (gamPushNew _lhsItyKiGam) of
                                                                                                                                                                                                            { _tyExprOtyKiGam | _tyExprOtyKiGam `seq` (True) ->
                                                                                                                                                                                                            (case (gamPushNew _lhsItyGam) of
                                                                                                                                                                                                             { _tyExprOtyGam | _tyExprOtyGam `seq` (True) ->
                                                                                                                                                                                                             (case (mkPolVar _lUniq_17_polCtx) of
                                                                                                                                                                                                              { _polCtxVar | _polCtxVar `seq` (True) ->
                                                                                                                                                                                                              (case (tyExpr_2 _tyExprOtyGam) of
                                                                                                                                                                                                               { ( _tyExprIty,_tyExprItyGam,tyExpr_3) | True ->
                                                                                                                                                                                                                   (case (maybe _polCtxVar id _lhsImbKnPolCtx) of
                                                                                                                                                                                                                    { _tyExprOknPolCtx | _tyExprOknPolCtx `seq` (True) ->
                                                                                                                                                                                                                    (case (tyExpr_3 _tyExprOknPolCtx) of
                                                                                                                                                                                                                     { ( _tyExprIpolVarL,tyExpr_4) | True ->
                                                                                                                                                                                                                         (case (tyExpr_4 _tyExprOpolGam _tyExprOpolVarMp) of
                                                                                                                                                                                                                          { ( _tyExprImbStrictness,_tyExprIpolVarMp,tyExpr_5) | True ->
                                                                                                                                                                                                                              (case (tyExpr_5 _tyExprOtyKiGam) of
                                                                                                                                                                                                                               { ( _tyExprIintlTyKiGam,_tyExprItyKiGam,tyExpr_6) | True ->
                                                                                                                                                                                                                                   (case (tyExpr_6 _tyExprOkiVarMp) of
                                                                                                                                                                                                                                    { ( _tyExprIgathTyVarPolGam,_tyExprIki,_tyExprIkiVarMp,_tyExprIpol,_tyExprItyVarWildMp,tyExpr_7) | True ->
                                                                                                                                                                                                                                        (case (fitsIn weakFIOpts defaultFIEnv _lUniq2 _tyExprIkiVarMp _tyExprIki kiStar) of
                                                                                                                                                                                                                                         { _fo_ | _fo_ `seq` (True) ->
                                                                                                                                                                                                                                         (case (foVarMp _fo_ `varUpd` _tyExprIkiVarMp) of
                                                                                                                                                                                                                                          { _lhsOkiVarMp | _lhsOkiVarMp `seq` (True) ->
                                                                                                                                                                                                                                          (case (_tyExprIpolVarMp) of
                                                                                                                                                                                                                                           { _lhsOpolVarMp | _lhsOpolVarMp `seq` (True) ->
                                                                                                                                                                                                                                           (case ((let sem_Decl_TySig_8 :: T_Decl_8
                                                                                                                                                                                                                                                       sem_Decl_TySig_8 =
                                                                                                                                                                                                                                                           (\ _lhsIpatClGam1 ->
                                                                                                                                                                                                                                                                _lhsIpatClGam1 `seq`
                                                                                                                                                                                                                                                                ((case (_lhsIpatClGam1) of
                                                                                                                                                                                                                                                                  { _lhsOpatClGam1 | _lhsOpatClGam1 `seq` (True) ->
                                                                                                                                                                                                                                                                  (case ((let sem_Decl_TySig_9 :: T_Decl_9
                                                                                                                                                                                                                                                                              sem_Decl_TySig_9 =
                                                                                                                                                                                                                                                                                  (\ _lhsIfinKiVarMp
                                                                                                                                                                                                                                                                                     _lhsIfinTyKiGam
                                                                                                                                                                                                                                                                                     _lhsIpatClGam2
                                                                                                                                                                                                                                                                                     _lhsItyTyTySigFreeTvarS ->
                                                                                                                                                                                                                                                                                       _lhsIfinKiVarMp `seq`
                                                                                                                                                                                                                                                                                       (_lhsIfinTyKiGam `seq`
                                                                                                                                                                                                                                                                                        (_lhsIpatClGam2 `seq`
                                                                                                                                                                                                                                                                                         (_lhsItyTyTySigFreeTvarS `seq`
                                                                                                                                                                                                                                                                                          ((case (_lhsIpatClGam2) of
                                                                                                                                                                                                                                                                                            { _lhsOpatClGam2 | _lhsOpatClGam2 `seq` (True) ->
                                                                                                                                                                                                                                                                                            (case ((let sem_Decl_TySig_10 :: T_Decl_10
                                                                                                                                                                                                                                                                                                        sem_Decl_TySig_10 =
                                                                                                                                                                                                                                                                                                            (\ _lhsIclGam
                                                                                                                                                                                                                                                                                                               _lhsIgathDataGam ->
                                                                                                                                                                                                                                                                                                                 _lhsIclGam `seq`
                                                                                                                                                                                                                                                                                                                 (_lhsIgathDataGam `seq`
                                                                                                                                                                                                                                                                                                                  ((case (_lhsIgathDataGam) of
                                                                                                                                                                                                                                                                                                                    { _lhsOgathDataGam | _lhsOgathDataGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                    (case (emptyGam) of
                                                                                                                                                                                                                                                                                                                     { _lhsOgathDeclDataGam | _lhsOgathDeclDataGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                     (case (__tup23) of
                                                                                                                                                                                                                                                                                                                      { (_,_,_,_lUniq_sig) | _lUniq_sig `seq` (True) ->
                                                                                                                                                                                                                                                                                                                      (case (_lhsItyTyTySigFreeTvarS) of
                                                                                                                                                                                                                                                                                                                       { _tyTyUpdFreeTvarS | _tyTyUpdFreeTvarS `seq` (True) ->
                                                                                                                                                                                                                                                                                                                       (case (_tyTyUpdFreeTvarS) of
                                                                                                                                                                                                                                                                                                                        { _gTyTvS | _gTyTvS `seq` (True) ->
                                                                                                                                                                                                                                                                                                                        (case (let fv  = Map.keysSet _tyExprItyVarWildMp `Set.union` _gTyTvS
                                                                                                                                                                                                                                                                                                                                   t   = varmpIncMetaLev _lhsIfinKiVarMp `varUpd` _tyExprIty
                                                                                                                                                                                                                                                                                                                                   t2k = tvarKi _lhsIfinTyKiGam _tyExprIintlTyKiGam _lhsIfinKiVarMp emptyVarMp
                                                                                                                                                                                                                                                                                                                               in  tyQuantifyOuter t2k (`Set.member` fv) t) of
                                                                                                                                                                                                                                                                                                                         { _ty_sig_ | _ty_sig_ `seq` (True) ->
                                                                                                                                                                                                                                                                                                                         (case (_ty_sig_) of
                                                                                                                                                                                                                                                                                                                          { _gamSigTy | _gamSigTy `seq` (True) ->
                                                                                                                                                                                                                                                                                                                          (case (let (t,m) = tyAsVarMp _lUniq_sig _gamSigTy
                                                                                                                                                                                                                                                                                                                                 in  (nm_ `gamSingleton` ValGamInfo t, m)) of
                                                                                                                                                                                                                                                                                                                           { __tup22 | __tup22 `seq` (True) ->
                                                                                                                                                                                                                                                                                                                           (case (__tup22) of
                                                                                                                                                                                                                                                                                                                            { (_gathTySigGam,_) | _gathTySigGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                            (case (_gathTySigGam) of
                                                                                                                                                                                                                                                                                                                             { _lhsOgathTySigGam | _lhsOgathTySigGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                             (case (__tup22) of
                                                                                                                                                                                                                                                                                                                              { (_,_gathTySigVarMp) | _gathTySigVarMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                              (case (_gathTySigVarMp) of
                                                                                                                                                                                                                                                                                                                               { _lhsOgathTySigVarMp | _lhsOgathTySigVarMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                               (case ((let sem_Decl_TySig_11 :: T_Decl_11
                                                                                                                                                                                                                                                                                                                                           sem_Decl_TySig_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_Decl_TySig_12 :: T_Decl_12
                                                                                                                                                                                                                                                                                                                                                                    sem_Decl_TySig_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_Decl_TySig_13 :: T_Decl_13
                                                                                                                                                                                                                                                                                                                                                                                                sem_Decl_TySig_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 (_tyExprIintlTyKiGam) of
                                                                                                                                                                                                                                                                                                                                                                                                                  { _lhsOintlTyKiGam | _lhsOintlTyKiGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                  (case (tvwmpNoQuantS _tyExprItyVarWildMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                   { _lhsOnoLetQuantTyVarIdS | _lhsOnoLetQuantTyVarIdS `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                   (case (emptyGam) of
                                                                                                                                                                                                                                                                                                                                                                                                                    { _lhsOscopeGam | _lhsOscopeGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                    (case (_lhsItyVarMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                     { _lhsOtyVarMp | _lhsOtyVarMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                     (case ((let sem_Decl_TySig_14 :: T_Decl_14
                                                                                                                                                                                                                                                                                                                                                                                                                                 sem_Decl_TySig_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 (_lhsIclGam) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                      { _tyExprOclGam | _tyExprOclGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                      (case (tyExpr_7 _tyExprOclGam) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                       { ( _tyExprIevTy,tyExpr_8) | True ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                           (case (_lhsIvalTyGlobFreeTvarS) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                            { _tyExprOvalTyGlobFreeTvarS | _tyExprOvalTyGlobFreeTvarS `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                            (case (_lhsItyTyTySigFreeTvarS) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                             { _tyExprOtyTyTySigFreeTvarS | _tyExprOtyTyTySigFreeTvarS `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                             (case (_lhsItyTyGlobFreeTvarS) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                              { _tyExprOtyTyGlobFreeTvarS | _tyExprOtyTyGlobFreeTvarS `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                              (case (_lhsItyKiGlobFreeTvarS) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                               { _tyExprOtyKiGlobFreeTvarS | _tyExprOtyKiGlobFreeTvarS `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                               (case (_lhsItr) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                { _tyExprOtr | _tyExprOtr `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                (case (_lhsIsysfEnv) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                 { _tyExprOsysfEnv | _tyExprOsysfEnv `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                 (case (_lhsIopts) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  { _tyExprOopts | _tyExprOopts `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (case (_lhsImoduleNm) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                   { _tyExprOmoduleNm | _tyExprOmoduleNm `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                   (case (_lhsIkiGam) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    { _tyExprOkiGam | _tyExprOkiGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (case (_lhsIfinTyVarMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                     { _tyExprOfinTyVarMp | _tyExprOfinTyVarMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                     (case (_lhsIfinTyKiGam) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      { _tyExprOfinTyKiGam | _tyExprOfinTyKiGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      (case (_lhsIfinKiVarMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                       { _tyExprOfinKiVarMp | _tyExprOfinKiVarMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                       (case (tyExpr_8 _tyExprOfinKiVarMp _tyExprOfinTyKiGam _tyExprOfinTyVarMp _tyExprOkiGam _tyExprOmoduleNm _tyExprOopts _tyExprOsysfEnv _tyExprOtr _tyExprOtyKiGlobFreeTvarS _tyExprOtyTyGlobFreeTvarS _tyExprOtyTyTySigFreeTvarS _tyExprOvalTyGlobFreeTvarS) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        { ( _tyExprIallErrSq,_tyExprIappArgPPL,_tyExprIappFunNm,_tyExprIappFunPP,_tyExprIclMissNmS,_tyExprIclNmS,_tyExprIerrSq,_tyExprIgathMentrelFilterMp,_tyExprIpp,_tyExprIppAST,_tyExprItrpp,_tyExprItyWildL) | True ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (case (_tyExprIallErrSq) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                             { _lhsOallErrSq | _lhsOallErrSq `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                             (case ([]) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              { _lhsObangEvalL | _lhsObangEvalL `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              (case (_lhsIcSubst) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                               { _lhsOcSubst | _lhsOcSubst `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                               (case (rngLift _range mkNestErr' _tyExprIpp [ _tyExprIerrSq
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           , foErrSq _fo_
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           ]) 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 (_tyExprIgathMentrelFilterMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     { _lhsOgathMentrelFilterMp | _lhsOgathMentrelFilterMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     (case (emptyVarMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      { _lhsOgathTvKiVarMp | _lhsOgathTvKiVarMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      (case (Set.empty) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       { _lhsOorphanS | _lhsOorphanS `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       (case (_tyExprIpp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        { _tyPP | _tyPP `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (case (nm_ >#< "::" >#< _tyPP) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         { _pp | _pp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         (case (_pp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          { _lhsOpp | _lhsOpp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          (case (trppEmpty) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           { _trppHere | _trppHere `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           (case (ppNestTrPP _lhsIopts ["Decl","TySig"] [ppTrNm nm_] [_tyExprIppAST] _trppHere) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            { _lhsOppAST | _lhsOppAST `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (case (_tyExprItrpp) 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_Decl_TySig_14)) of
                                                                                                                                                                                                                                                                                                                                                                                                                      { ( sem_Decl_14) | True ->
                                                                                                                                                                                                                                                                                                                                                                                                                      ( _lhsOgathCnstrMp,_lhsOgathRangeMp,_lhsOintlTyKiGam,_lhsOnoLetQuantTyVarIdS,_lhsOscopeGam,_lhsOtyVarMp,sem_Decl_14) }) }) }) }) }) }) }))))))))
                                                                                                                                                                                                                                                                                                                                                                                            in  sem_Decl_TySig_13)) of
                                                                                                                                                                                                                                                                                                                                                                                     { ( sem_Decl_13) | True ->
                                                                                                                                                                                                                                                                                                                                                                                     ( _lhsOpatTyVarMp,_lhsOpatValGam,sem_Decl_13) }) }) })))))))
                                                                                                                                                                                                                                                                                                                                                                in  sem_Decl_TySig_12)) of
                                                                                                                                                                                                                                                                                                                                                         { ( sem_Decl_12) | True ->
                                                                                                                                                                                                                                                                                                                                                         ( _lhsOchrClassDeclSq,_lhsOchrInstDeclSq,_lhsOgathClDfGam,sem_Decl_12) }) }) }) })))
                                                                                                                                                                                                                                                                                                                                       in  sem_Decl_TySig_11)) of
                                                                                                                                                                                                                                                                                                                                { ( sem_Decl_11) | True ->
                                                                                                                                                                                                                                                                                                                                ( _lhsOgathDataGam,_lhsOgathDeclDataGam,_lhsOgathTySigGam,_lhsOgathTySigVarMp,sem_Decl_11) }) }) }) }) }) }) }) }) }) }) }) }) }))))
                                                                                                                                                                                                                                                                                                    in  sem_Decl_TySig_10)) of
                                                                                                                                                                                                                                                                                             { ( sem_Decl_10) | True ->
                                                                                                                                                                                                                                                                                             ( _lhsOpatClGam2,sem_Decl_10) }) }))))))
                                                                                                                                                                                                                                                                          in  sem_Decl_TySig_9)) of
                                                                                                                                                                                                                                                                   { ( sem_Decl_9) | True ->
                                                                                                                                                                                                                                                                   ( _lhsOpatClGam1,sem_Decl_9) }) })))
                                                                                                                                                                                                                                                   in  sem_Decl_TySig_8)) of
                                                                                                                                                                                                                                            { ( sem_Decl_8) | True ->
                                                                                                                                                                                                                                            ( _lhsOgenerDataInfoL,_lhsOgenerDataInfoMp,_lhsOkiVarMp,_lhsOpolVarMp,sem_Decl_8) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }))))))))))
                                                                                                                                                                               in  sem_Decl_TySig_7)) of
                                                                                                                                                                        { ( sem_Decl_7) | True ->
                                                                                                                                                                        ( _lhsOpatKiVarMp,_lhsOpatPolGam,sem_Decl_7) }) }) })))))
                                                                                                                                                     in  sem_Decl_TySig_6)) of
                                                                                                                                              { ( sem_Decl_6) | True ->
                                                                                                                                              ( _lhsOpatTyKiGam,_lhsOtyTyVarMp,sem_Decl_6) }) }) })))))
                                                                                                                           in  sem_Decl_TySig_5)) of
                                                                                                                    { ( sem_Decl_5) | True ->
                                                                                                                    ( _lhsOpatTyGam,sem_Decl_5) }) }))))
                                                                                                   in  sem_Decl_TySig_4)) of
                                                                                            { ( sem_Decl_4) | True ->
                                                                                            ( _lhsOpredSameScopeCounter,sem_Decl_4) }) }))))
                                                                           in  sem_Decl_TySig_3)) of
                                                                    { ( sem_Decl_3) | True ->
                                                                    ( _lhsOgathTyKiSigGam,sem_Decl_3) }) })))
                                                    in  sem_Decl_TySig_2)) of
                                             { ( sem_Decl_2) | True ->
                                             ( _lhsOgUniq,_lhsOgathKiSigGam,_lhsOhasInstDecl,sem_Decl_2) }) }) }) }) }) }) }))))
                   in  sem_Decl_TySig_1)) of
            { ( sem_Decl_1) | True ->
            ( _lhsOrange,sem_Decl_1) }) }) }) })

sem_Decl_Val :: Range ->
                T_PatExpr ->
                T_Expr ->
                T_Decl

sem_Decl_Val hsrange_ patExpr_ expr_ | hsrange_ `seq` (patExpr_ `seq` (expr_ `seq` (True))) =
    (case (expr_) of
     { ( _exprIrange,expr_1) | True ->
         (case (patExpr_) of
          { ( _patExprIrange,patExpr_1) | True ->
              (case (rangeUnions [hsrange_, _patExprIrange, _exprIrange  ]) of
               { _range | _range `seq` (True) ->
               (case (_range) of
                { _lhsOrange | _lhsOrange `seq` (True) ->
                (case ((let sem_Decl_Val_1 :: T_Decl_1
                            sem_Decl_Val_1 =
                                (\ _lhsIgUniq
                                   _lhsIgathKiSigGam ->
                                     _lhsIgUniq `seq`
                                     (_lhsIgathKiSigGam `seq`
                                      ((case (let __cont = _lhsIgUniq in seq __cont ( case nextUnique __cont of { (__cont, lUniq) -> (__cont,lUniq)} )) of
                                        { __tup26 | __tup26 `seq` (True) ->
                                        (case (__tup26) of
                                         { (_patExprOgUniq,_) | _patExprOgUniq `seq` (True) ->
                                         (case (patExpr_1 _patExprOgUniq) of
                                          { ( _patExprIgUniq,patExpr_2) | True ->
                                              (case (_patExprIgUniq) of
                                               { _exprOgUniq | _exprOgUniq `seq` (True) ->
                                               (case (expr_1 _exprOgUniq) of
                                                { ( _exprIgUniq,_exprIhasInstDecl,expr_2) | True ->
                                                    (case (_exprIgUniq) of
                                                     { _lhsOgUniq | _lhsOgUniq `seq` (True) ->
                                                     (case (_lhsIgathKiSigGam) of
                                                      { _lhsOgathKiSigGam | _lhsOgathKiSigGam `seq` (True) ->
                                                      (case (False) of
                                                       { _lhsOhasInstDecl | _lhsOhasInstDecl `seq` (True) ->
                                                       (case ((let sem_Decl_Val_2 :: T_Decl_2
                                                                   sem_Decl_Val_2 =
                                                                       (\ _lhsIkiGam ->
                                                                            _lhsIkiGam `seq`
                                                                            ((case (emptyGam) of
                                                                              { _lhsOgathTyKiSigGam | _lhsOgathTyKiSigGam `seq` (True) ->
                                                                              (case ((let sem_Decl_Val_3 :: T_Decl_3
                                                                                          sem_Decl_Val_3 =
                                                                                              (\ _lhsIlexLev
                                                                                                 _lhsIpredSameScopeCounter ->
                                                                                                   _lhsIlexLev `seq`
                                                                                                   (_lhsIpredSameScopeCounter `seq`
                                                                                                    ((case (_lhsIpredSameScopeCounter+1) of
                                                                                                      { _lhsOpredSameScopeCounter | _lhsOpredSameScopeCounter `seq` (True) ->
                                                                                                      (case ((let sem_Decl_Val_4 :: T_Decl_4
                                                                                                                  sem_Decl_Val_4 =
                                                                                                                      (\ _lhsIpatTyGam
                                                                                                                         _lhsItyKiSigGam ->
                                                                                                                           _lhsIpatTyGam `seq`
                                                                                                                           (_lhsItyKiSigGam `seq`
                                                                                                                            ((case (_lhsIpatTyGam) of
                                                                                                                              { _lhsOpatTyGam | _lhsOpatTyGam `seq` (True) ->
                                                                                                                              (case ((let sem_Decl_Val_5 :: T_Decl_5
                                                                                                                                          sem_Decl_Val_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_Decl_Val_6 :: T_Decl_6
                                                                                                                                                                    sem_Decl_Val_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_Decl_Val_7 :: T_Decl_7
                                                                                                                                                                                              sem_Decl_Val_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 (_lhsItyKiGlobFreeTvarS) of
                                                                                                                                                                                                                 { _exprOtyKiGlobFreeTvarS | _exprOtyKiGlobFreeTvarS `seq` (True) ->
                                                                                                                                                                                                                 (case (_lhsItyKiGlobFreeTvarS) of
                                                                                                                                                                                                                  { _patExprOtyKiGlobFreeTvarS | _patExprOtyKiGlobFreeTvarS `seq` (True) ->
                                                                                                                                                                                                                  (case (_lhsItyKiGam) of
                                                                                                                                                                                                                   { _patExprOtyKiGam | _patExprOtyKiGam `seq` (True) ->
                                                                                                                                                                                                                   (case (_lhsItyGam) of
                                                                                                                                                                                                                    { _patExprOtyGam | _patExprOtyGam `seq` (True) ->
                                                                                                                                                                                                                    (case (snd $ pscpEnter _lhsIpredSameScopeCounter _lhsIpredScope) of
                                                                                                                                                                                                                     { _predScope | _predScope `seq` (True) ->
                                                                                                                                                                                                                     (case (_predScope) of
                                                                                                                                                                                                                      { _patExprOpredScope | _patExprOpredScope `seq` (True) ->
                                                                                                                                                                                                                      (case (_lhsIpredSameScopeCounter) of
                                                                                                                                                                                                                       { _patExprOpredSameScopeCounter | _patExprOpredSameScopeCounter `seq` (True) ->
                                                                                                                                                                                                                       (case (_lhsIpolVarMp) of
                                                                                                                                                                                                                        { _patExprOpolVarMp | _patExprOpolVarMp `seq` (True) ->
                                                                                                                                                                                                                        (case (_lhsIpolGam) of
                                                                                                                                                                                                                         { _patExprOpolGam | _patExprOpolGam `seq` (True) ->
                                                                                                                                                                                                                         (case (_lhsIopts) of
                                                                                                                                                                                                                          { _patExprOopts | _patExprOopts `seq` (True) ->
                                                                                                                                                                                                                          (case (_lhsIlexLev) of
                                                                                                                                                                                                                           { _patExprOlexLev | _patExprOlexLev `seq` (True) ->
                                                                                                                                                                                                                           (case (_lhsIkiVarMp) of
                                                                                                                                                                                                                            { _patExprOkiVarMp | _patExprOkiVarMp `seq` (True) ->
                                                                                                                                                                                                                            (case (_lhsIkiGam) of
                                                                                                                                                                                                                             { _patExprOkiGam | _patExprOkiGam `seq` (True) ->
                                                                                                                                                                                                                             (case (_lhsIgenerDataInfoMp) of
                                                                                                                                                                                                                              { _patExprOgenerDataInfoMp | _patExprOgenerDataInfoMp `seq` (True) ->
                                                                                                                                                                                                                              (case (patExpr_2 _patExprOkiGam _patExprOlexLev _patExprOpredSameScopeCounter) of
                                                                                                                                                                                                                               { ( _patExprIpredSameScopeCounter,patExpr_3) | True ->
                                                                                                                                                                                                                                   (case (patExpr_3 _patExprOgenerDataInfoMp _patExprOkiVarMp _patExprOopts _patExprOpolGam _patExprOpolVarMp _patExprOpredScope _patExprOtyGam _patExprOtyKiGam _patExprOtyKiGlobFreeTvarS) of
                                                                                                                                                                                                                                    { ( _patExprIgenerDataInfoMp,_patExprIkiVarMp,_patExprIpolVarMp,_patExprItyGam,_patExprItyKiGam,patExpr_4) | True ->
                                                                                                                                                                                                                                        (case (_patExprItyKiGam) of
                                                                                                                                                                                                                                         { _exprOtyKiGam | _exprOtyKiGam `seq` (True) ->
                                                                                                                                                                                                                                         (case (_patExprItyGam) of
                                                                                                                                                                                                                                          { _exprOtyGam | _exprOtyGam `seq` (True) ->
                                                                                                                                                                                                                                          (case (_predScope) of
                                                                                                                                                                                                                                           { _exprOpredScope | _exprOpredScope `seq` (True) ->
                                                                                                                                                                                                                                           (case (_patExprIpolVarMp) of
                                                                                                                                                                                                                                            { _exprOpolVarMp | _exprOpolVarMp `seq` (True) ->
                                                                                                                                                                                                                                            (case (_lhsIpolGam) of
                                                                                                                                                                                                                                             { _exprOpolGam | _exprOpolGam `seq` (True) ->
                                                                                                                                                                                                                                             (case (_lhsIopts) of
                                                                                                                                                                                                                                              { _exprOopts | _exprOopts `seq` (True) ->
                                                                                                                                                                                                                                              (case (_lhsIlexLev) of
                                                                                                                                                                                                                                               { _exprOlexLev | _exprOlexLev `seq` (True) ->
                                                                                                                                                                                                                                               (case (_patExprIkiVarMp) of
                                                                                                                                                                                                                                                { _exprOkiVarMp | _exprOkiVarMp `seq` (True) ->
                                                                                                                                                                                                                                                (case (_lhsIkiGam) of
                                                                                                                                                                                                                                                 { _exprOkiGam | _exprOkiGam `seq` (True) ->
                                                                                                                                                                                                                                                 (case (_patExprIgenerDataInfoMp) of
                                                                                                                                                                                                                                                  { _exprOgenerDataInfoMp | _exprOgenerDataInfoMp `seq` (True) ->
                                                                                                                                                                                                                                                  (case (True) of
                                                                                                                                                                                                                                                   { _exprOisFirstLet | _exprOisFirstLet `seq` (True) ->
                                                                                                                                                                                                                                                   (case (0) of
                                                                                                                                                                                                                                                    { _exprOpredSameScopeCounter | _exprOpredSameScopeCounter `seq` (True) ->
                                                                                                                                                                                                                                                    (case (expr_2 _exprOisFirstLet _exprOkiGam _exprOlexLev _exprOpredSameScopeCounter) of
                                                                                                                                                                                                                                                     { ( _exprIpredSameScopeCounter,expr_3) | True ->
                                                                                                                                                                                                                                                         (case (expr_3 _exprOgenerDataInfoMp _exprOkiVarMp _exprOopts _exprOpolGam _exprOpolVarMp _exprOpredScope _exprOtyGam _exprOtyKiGam _exprOtyKiGlobFreeTvarS) of
                                                                                                                                                                                                                                                          { ( _exprIgenerDataInfoMp,_exprIkiVarMp,_exprIpolVarMp,expr_4) | True ->
                                                                                                                                                                                                                                                              (case (_exprIgenerDataInfoMp) of
                                                                                                                                                                                                                                                               { _lhsOgenerDataInfoMp | _lhsOgenerDataInfoMp `seq` (True) ->
                                                                                                                                                                                                                                                               (case (_exprIkiVarMp) of
                                                                                                                                                                                                                                                                { _lhsOkiVarMp | _lhsOkiVarMp `seq` (True) ->
                                                                                                                                                                                                                                                                (case (_exprIpolVarMp) of
                                                                                                                                                                                                                                                                 { _lhsOpolVarMp | _lhsOpolVarMp `seq` (True) ->
                                                                                                                                                                                                                                                                 (case ((let sem_Decl_Val_8 :: T_Decl_8
                                                                                                                                                                                                                                                                             sem_Decl_Val_8 =
                                                                                                                                                                                                                                                                                 (\ _lhsIpatClGam1 ->
                                                                                                                                                                                                                                                                                      _lhsIpatClGam1 `seq`
                                                                                                                                                                                                                                                                                      ((case (_lhsIpatClGam1) of
                                                                                                                                                                                                                                                                                        { _lhsOpatClGam1 | _lhsOpatClGam1 `seq` (True) ->
                                                                                                                                                                                                                                                                                        (case ((let sem_Decl_Val_9 :: T_Decl_9
                                                                                                                                                                                                                                                                                                    sem_Decl_Val_9 =
                                                                                                                                                                                                                                                                                                        (\ _lhsIfinKiVarMp
                                                                                                                                                                                                                                                                                                           _lhsIfinTyKiGam
                                                                                                                                                                                                                                                                                                           _lhsIpatClGam2
                                                                                                                                                                                                                                                                                                           _lhsItyTyTySigFreeTvarS ->
                                                                                                                                                                                                                                                                                                             _lhsIfinKiVarMp `seq`
                                                                                                                                                                                                                                                                                                             (_lhsIfinTyKiGam `seq`
                                                                                                                                                                                                                                                                                                              (_lhsIpatClGam2 `seq`
                                                                                                                                                                                                                                                                                                               (_lhsItyTyTySigFreeTvarS `seq`
                                                                                                                                                                                                                                                                                                                ((case (_lhsIpatClGam2) of
                                                                                                                                                                                                                                                                                                                  { _lhsOpatClGam2 | _lhsOpatClGam2 `seq` (True) ->
                                                                                                                                                                                                                                                                                                                  (case ((let sem_Decl_Val_10 :: T_Decl_10
                                                                                                                                                                                                                                                                                                                              sem_Decl_Val_10 =
                                                                                                                                                                                                                                                                                                                                  (\ _lhsIclGam
                                                                                                                                                                                                                                                                                                                                     _lhsIgathDataGam ->
                                                                                                                                                                                                                                                                                                                                       _lhsIclGam `seq`
                                                                                                                                                                                                                                                                                                                                       (_lhsIgathDataGam `seq`
                                                                                                                                                                                                                                                                                                                                        ((case (_lhsItyTyTySigFreeTvarS) of
                                                                                                                                                                                                                                                                                                                                          { _exprOtyTyTySigFreeTvarS | _exprOtyTyTySigFreeTvarS `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                          (case (_lhsIgathDataGam) of
                                                                                                                                                                                                                                                                                                                                           { _exprOgathDataGam | _exprOgathDataGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                           (case (_lhsIfinTyKiGam) of
                                                                                                                                                                                                                                                                                                                                            { _exprOfinTyKiGam | _exprOfinTyKiGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                            (case (_lhsIfinKiVarMp) of
                                                                                                                                                                                                                                                                                                                                             { _exprOfinKiVarMp | _exprOfinKiVarMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                             (case (_lhsIclGam) of
                                                                                                                                                                                                                                                                                                                                              { _exprOclGam | _exprOclGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                              (case (expr_4 _exprOclGam _exprOfinKiVarMp _exprOfinTyKiGam _exprOgathDataGam _exprOtyTyTySigFreeTvarS) of
                                                                                                                                                                                                                                                                                                                                               { ( _exprIgathDataGam,expr_5) | True ->
                                                                                                                                                                                                                                                                                                                                                   (case (_exprIgathDataGam) 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_Decl_Val_11 :: T_Decl_11
                                                                                                                                                                                                                                                                                                                                                                   sem_Decl_Val_11 =
                                                                                                                                                                                                                                                                                                                                                                       (\ _lhsIdataGam ->
                                                                                                                                                                                                                                                                                                                                                                            _lhsIdataGam `seq`
                                                                                                                                                                                                                                                                                                                                                                            ((case (_lhsIdataGam) of
                                                                                                                                                                                                                                                                                                                                                                              { _exprOdataGam | _exprOdataGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                              (case (expr_5 _exprOdataGam) of
                                                                                                                                                                                                                                                                                                                                                                               { ( _exprIchrClassDeclSq,_exprIchrFIIn,_exprIchrInstDeclSq,_exprIgathClDfGam,expr_6) | True ->
                                                                                                                                                                                                                                                                                                                                                                                   (case (_exprIchrClassDeclSq) of
                                                                                                                                                                                                                                                                                                                                                                                    { _lhsOchrClassDeclSq | _lhsOchrClassDeclSq `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                    (case (_lhsItyTyTySigFreeTvarS) of
                                                                                                                                                                                                                                                                                                                                                                                     { _patExprOtyTyTySigFreeTvarS | _patExprOtyTyTySigFreeTvarS `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                     (case (_lhsIfinTyKiGam) of
                                                                                                                                                                                                                                                                                                                                                                                      { _patExprOfinTyKiGam | _patExprOfinTyKiGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                      (case (_lhsIfinKiVarMp) of
                                                                                                                                                                                                                                                                                                                                                                                       { _patExprOfinKiVarMp | _patExprOfinKiVarMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                       (case (_lhsIdataGam) of
                                                                                                                                                                                                                                                                                                                                                                                        { _patExprOdataGam | _patExprOdataGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                        (case (_lhsIclGam) of
                                                                                                                                                                                                                                                                                                                                                                                         { _patExprOclGam | _patExprOclGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                         (case (patExpr_4 _patExprOclGam _patExprOdataGam _patExprOfinKiVarMp _patExprOfinTyKiGam _patExprOtyTyTySigFreeTvarS) of
                                                                                                                                                                                                                                                                                                                                                                                          { ( _patExprIchrInstDeclSq,_patExprItopNm,patExpr_5) | True ->
                                                                                                                                                                                                                                                                                                                                                                                              (case (_patExprIchrInstDeclSq `Seq.union` _exprIchrInstDeclSq) of
                                                                                                                                                                                                                                                                                                                                                                                               { _lhsOchrInstDeclSq | _lhsOchrInstDeclSq `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                               (case (_exprIgathClDfGam) of
                                                                                                                                                                                                                                                                                                                                                                                                { _lhsOgathClDfGam | _lhsOgathClDfGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                (case ((let sem_Decl_Val_12 :: T_Decl_12
                                                                                                                                                                                                                                                                                                                                                                                                            sem_Decl_Val_12 =
                                                                                                                                                                                                                                                                                                                                                                                                                (\ _lhsIpatTyVarMp
                                                                                                                                                                                                                                                                                                                                                                                                                   _lhsIpatValGam
                                                                                                                                                                                                                                                                                                                                                                                                                   _lhsItvKiVarMp
                                                                                                                                                                                                                                                                                                                                                                                                                   _lhsItySigGam
                                                                                                                                                                                                                                                                                                                                                                                                                   _lhsItySigVarMp ->
                                                                                                                                                                                                                                                                                                                                                                                                                     _lhsIpatTyVarMp `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                     (_lhsIpatValGam `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                      (_lhsItvKiVarMp `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                       (_lhsItySigGam `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                        (_lhsItySigVarMp `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                         ((case (_lhsItySigGam) of
                                                                                                                                                                                                                                                                                                                                                                                                                           { _patExprOtySigGam | _patExprOtySigGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                           (case (_lhsIpatTyVarMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                            { _patExprOpatTyVarMp | _patExprOpatTyVarMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                            (case (_lhsIpatValGam) of
                                                                                                                                                                                                                                                                                                                                                                                                                             { _patExprOvalGam | _patExprOvalGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                             (case (patExpr_5 _patExprOvalGam) of
                                                                                                                                                                                                                                                                                                                                                                                                                              { ( _patExprIarity,_patExprImbTopNm,_patExprIpatFunTy,patExpr_6) | True ->
                                                                                                                                                                                                                                                                                                                                                                                                                                  (case (case _patExprImbTopNm of
                                                                                                                                                                                                                                                                                                                                                                                                                                           Nothing
                                                                                                                                                                                                                                                                                                                                                                                                                                             ->  (Ty_Any,False)
                                                                                                                                                                                                                                                                                                                                                                                                                                           Just nm
                                                                                                                                                                                                                                                                                                                                                                                                                                             ->  case gamLookup nm _lhsItySigGam of
                                                                                                                                                                                                                                                                                                                                                                                                                                                   Nothing   -> (Ty_Any,False)
                                                                                                                                                                                                                                                                                                                                                                                                                                                   Just vgi  -> (_lhsItySigVarMp `varUpd` vgiTy vgi, True)) of
                                                                                                                                                                                                                                                                                                                                                                                                                                   { __tup25 | __tup25 `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                   (case (__tup25) of
                                                                                                                                                                                                                                                                                                                                                                                                                                    { (_ty_sig_,_) | _ty_sig_ `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                    (case (_ty_sig_) of
                                                                                                                                                                                                                                                                                                                                                                                                                                     { _knTy | _knTy `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                     (case (_knTy) of
                                                                                                                                                                                                                                                                                                                                                                                                                                      { _patExprOknTy | _patExprOknTy `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                      (case (__tup25) of
                                                                                                                                                                                                                                                                                                                                                                                                                                       { (_,_hasTySig) | _hasTySig `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                       (case (not _hasTySig) of
                                                                                                                                                                                                                                                                                                                                                                                                                                        { _patExprOinclVarBind | _patExprOinclVarBind `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                        (case ([]) of
                                                                                                                                                                                                                                                                                                                                                                                                                                         { _patExprOknTyL | _patExprOknTyL `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                         (case (strongFIOpts) of
                                                                                                                                                                                                                                                                                                                                                                                                                                          { _patExprOfiOpts | _patExprOfiOpts `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                          (case (patExpr_6 _patExprOfiOpts _patExprOinclVarBind _patExprOknTy _patExprOknTyL _patExprOpatTyVarMp _patExprOtySigGam) of
                                                                                                                                                                                                                                                                                                                                                                                                                                           { ( _patExprIpatTyVarMp,_patExprIvalGam,patExpr_7) | True ->
                                                                                                                                                                                                                                                                                                                                                                                                                                               (case (_patExprIpatTyVarMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                { _lhsOpatTyVarMp | _lhsOpatTyVarMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                (case (_patExprIvalGam) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                 { _lhsOpatValGam | _lhsOpatValGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                 (case ((let sem_Decl_Val_13 :: T_Decl_13
                                                                                                                                                                                                                                                                                                                                                                                                                                                             sem_Decl_Val_13 =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                 (\ _lhsIchrStore
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _lhsIclDfGam
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _lhsItyTyGlobFreeTvarS
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _lhsItyVarMp
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _lhsIvalGam
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _lhsIvalTyGlobFreeTvarS ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      _lhsIchrStore `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      (_lhsIclDfGam `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                       (_lhsItyTyGlobFreeTvarS `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (_lhsItyVarMp `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                         (_lhsIvalGam `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          (_lhsIvalTyGlobFreeTvarS `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                           ((case (_lhsIvalTyGlobFreeTvarS) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                             { _exprOvalTyGlobFreeTvarS | _exprOvalTyGlobFreeTvarS `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                             (case (_lhsIvalTyGlobFreeTvarS) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              { _patExprOvalTyGlobFreeTvarS | _patExprOvalTyGlobFreeTvarS `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              (case (_lhsItyVarMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                               { _patExprOtyVarMp | _patExprOtyVarMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                               (case (_lhsItyTyGlobFreeTvarS) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                { _patExprOtyTyGlobFreeTvarS | _patExprOtyTyGlobFreeTvarS `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (case (_lhsItvKiVarMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 { _patExprOtvKiVarMp | _patExprOtvKiVarMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 (case (_lhsIclDfGam) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  { _patExprOclDfGam | _patExprOclDfGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (case (_lhsIchrStore) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   { _patExprOchrStore | _patExprOchrStore `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   (case (patExpr_7 _patExprOchrStore _patExprOclDfGam _patExprOtvKiVarMp _patExprOtyTyGlobFreeTvarS _patExprOtyVarMp _patExprOvalTyGlobFreeTvarS) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    { ( _patExprIcpNm,_patExprIgathCnstrMp,_patExprIgathRangeMp,_patExprIscopeGam,_patExprIty,_patExprItyVarMp,patExpr_8) | True ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (case (_patExprItyVarMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         { _exprOtyVarMp | _exprOtyVarMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         (case (_lhsItyTyGlobFreeTvarS) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          { _exprOtyTyGlobFreeTvarS | _exprOtyTyGlobFreeTvarS `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          (case (_lhsItvKiVarMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           { _exprOtvKiVarMp | _exprOtvKiVarMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           (case (_lhsIclDfGam) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            { _exprOclDfGam | _exprOclDfGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (case (_lhsIchrStore) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             { _exprOchrStore | _exprOchrStore `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             (case (_lhsIvalGam) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              { _exprOvalGam | _exprOvalGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              (case (if _hasTySig then _knTy else _patExprIty) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               { _exprKnTy | _exprKnTy `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               (case (_exprKnTy) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                { _exprOknTy | _exprOknTy `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (case ((if _hasTySig then strongFIOpts else weakFIOpts)) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 { _exprOfiOpts | _exprOfiOpts `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 (case (expr_6 _exprOchrStore _exprOclDfGam _exprOfiOpts _exprOknTy _exprOtvKiVarMp _exprOtyTyGlobFreeTvarS _exprOtyVarMp _exprOvalGam _exprOvalTyGlobFreeTvarS) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  { ( _exprIgathCnstrMp,_exprIgathRangeMp,_exprIgathValGam,_exprInoLetQuantTyVarIdS,_exprIty,_exprItyVarMp,expr_7) | True ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      (case (_patExprIgathCnstrMp `cnstrMpUnion` _exprIgathCnstrMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       { _lhsOgathCnstrMp | _lhsOgathCnstrMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       (case (_patExprIgathRangeMp `Map.union` _exprIgathRangeMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        { _lhsOgathRangeMp | _lhsOgathRangeMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (case (emptyGam) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         { _lhsOintlTyKiGam | _lhsOintlTyKiGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         (case (_exprInoLetQuantTyVarIdS) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          { _lhsOnoLetQuantTyVarIdS | _lhsOnoLetQuantTyVarIdS `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          (case (_patExprIscopeGam) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           { _lhsOscopeGam | _lhsOscopeGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           (case (_exprItyVarMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            { _lhsOtyVarMp | _lhsOtyVarMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (case ((let sem_Decl_Val_14 :: T_Decl_14
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        sem_Decl_Val_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
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             { _exprOsysfEnv | _exprOsysfEnv `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             (case (_lhsIrangeMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              { _exprOrangeMp | _exprOrangeMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              (case (_lhsIfinValGam) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               { _exprOfinValGam | _exprOfinValGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               (case (_lhsIfinTyVarMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                { _exprOfinTyVarMp | _exprOfinTyVarMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (case (_lhsIsysfEnv) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 { _patExprOsysfEnv | _patExprOsysfEnv `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 (case (_lhsIrangeMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  { _patExprOrangeMp | _patExprOrangeMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (case (_lhsIfinValGam) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   { _patExprOfinValGam | _patExprOfinValGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   (case (_lhsIfinTyVarMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    { _patExprOfinTyVarMp | _patExprOfinTyVarMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (case (_lhsItr) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     { _exprOtr | _exprOtr `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     (case (_lhsImoduleNm) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      { _exprOmoduleNm | _exprOmoduleNm `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      (case (mkScopeBindings False _predScope _lhsIchrScopeBindMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       { __tup24 | __tup24 `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       (case (__tup24) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        { (_,_chrScopeBindMp) | _chrScopeBindMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (case (_chrScopeBindMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         { _exprOchrScopeBindMp | _exprOchrScopeBindMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         (case (_lhsIchrEvidBindMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          { _exprOchrEvidBindMp | _exprOchrEvidBindMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          (case (_chrScopeBindMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           { _patExprOchrScopeBindMp | _patExprOchrScopeBindMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           (case (_lhsIchrEvidBindMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            { _patExprOchrEvidBindMp | _patExprOchrEvidBindMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (case (_lhsIcSubst) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             { _patExprOcSubst | _patExprOcSubst `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             (case (_lhsItySigVarMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              { _patExprOtySigVarMp | _patExprOtySigVarMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              (case (_lhsItr) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               { _patExprOtr | _patExprOtr `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               (case (_lhsImoduleNm) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                { _patExprOmoduleNm | _patExprOmoduleNm `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (case (_patExprItopNm) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 { _patExprOceParentNm | _patExprOceParentNm `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 (case (patExpr_8 _patExprOcSubst _patExprOceParentNm _patExprOchrEvidBindMp _patExprOchrScopeBindMp _patExprOfinTyVarMp _patExprOfinValGam _patExprOmoduleNm _patExprOrangeMp _patExprOsysfEnv _patExprOtr _patExprOtySigVarMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  { ( _patExprIallErrSq,_patExprIappArgPPL,_patExprIappFunNm,_patExprIappFunPP,_patExprIcSubst,_patExprIerrSq,_patExprIfsRPatL,_patExprIgathMentrelFilterMp,_patExprIgathTvKiVarMp,_patExprIisBang,_patExprIpatCRest,_patExprIpp,_patExprIppAST,_patExprIrpat,_patExprItrpp,_patExprIvalCBindL) | True ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      (case (_patExprIcSubst) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       { _exprOcSubst | _exprOcSubst `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       (case (ExprCtxt_Top) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        { _exprOexprCtxt | _exprOexprCtxt `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (case (expr_7 _exprOcSubst _exprOchrEvidBindMp _exprOchrScopeBindMp _exprOexprCtxt _exprOfinTyVarMp _exprOfinValGam _exprOmoduleNm _exprOrangeMp _exprOsysfEnv _exprOtr) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         { ( _exprIallErrSq,_exprIappArgCoeL,_exprIappArgPPL,_exprIappFunCExpr,_exprIappFunNm,_exprIappFunPP,_exprIbackCBindL,_exprIcSubst,_exprIcaseFailS,_exprIcexpr,_exprIerrSq,_exprIfrontCBindL,_exprIfuCExprL,_exprIgathClGam,_exprIgathHiddenExports,_exprIgathKiGam,_exprIgathLamMp,_exprIgathMentrelFilterMp,_exprIgathPolGam,_exprIgathTvKiVarMp,_exprIgathTyGam,_exprIgathTyKiGam,_exprIisNewtype,_exprIlamArgPPL,_exprIlamBodyPP,_exprIletCBody,_exprIletTyCBindL,_exprIletValCBindL,_exprIletValMainCBindL,_exprIorphanS,_exprIpp,_exprIppAST,_exprItrpp) | True ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             (case (_patExprIallErrSq `Seq.union` _exprIallErrSq) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              { _lhsOallErrSq | _lhsOallErrSq `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              (case (maybe (appDbg "EH.FinalInfo.Decl.Val.finalTy")      vgiTy $ valGamLookup _patExprItopNm _lhsIfinValGam) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               { _finalTy | _finalTy `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               (case (defaultFIEnv
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          { feTyGam = _lhsItyGam
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          , feEHCOpts = _lhsIopts
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          , feDataGam = _lhsIdataGam
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          , fePolGam = _lhsIpolGam
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          , feRange = _range
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          }) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                { _fe | _fe `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (case (tyCanonicFFI (emptyTyBetaRedEnv' _fe) _finalTy) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 { _finalTyExpanded | _finalTyExpanded `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 (case ((appDbg "{Expr,PatExpr,Decl,DataFieldExpr}.sysfty not implemented" :: SysfTy)) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  { _sysfty | _sysfty `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (case (mkCTy _lhsIopts _finalTyExpanded _sysfty) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   { _acorety | _acorety `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   (case (if _patExprIisBang then [acoreLet1StrictTy (hsnUniqify HsNameUniqifier_Strict _patExprItopNm) _acorety (acoreVar _patExprItopNm)] else []) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    { _lhsObangEvalL | _lhsObangEvalL `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (case (_exprIcSubst) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     { _lhsOcSubst | _lhsOcSubst `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     (case (Seq.unions [_patExprIerrSq, _exprIerrSq]) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      { _lhsOerrSq | _lhsOerrSq `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      (case ([]) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       { _lhsOffeCBindL | _lhsOffeCBindL `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       (case ([]) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        { _lhsOffiCBindL | _lhsOffiCBindL `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (case (_exprIgathHiddenExports) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         { _lhsOgathHiddenExports | _lhsOgathHiddenExports `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         (case (_exprIgathLamMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          { _lhsOgathLamMp | _lhsOgathLamMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          (case (_patExprIgathMentrelFilterMp `mentrelFilterMpUnion` _exprIgathMentrelFilterMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           { _lhsOgathMentrelFilterMp | _lhsOgathMentrelFilterMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           (case (_patExprIgathTvKiVarMp `varmpUnion` _exprIgathTvKiVarMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            { _lhsOgathTvKiVarMp | _lhsOgathTvKiVarMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (case (_exprIorphanS) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             { _lhsOorphanS | _lhsOorphanS `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             (case (_patExprIpp >###< "=" >#< _exprIpp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              { _pp | _pp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              (case (_pp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               { _lhsOpp | _lhsOpp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               (case (trppEmpty) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                { _trppHere | _trppHere `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (case (ppNestTrPP _lhsIopts ["Decl","Val"] [] [_patExprIppAST,_exprIppAST] _trppHere) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 { _lhsOppAST | _lhsOppAST `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 (case (_patExprItrpp >< _exprItrpp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  { _lhsOtrpp | _lhsOtrpp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (case ([]) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   { _lhsOtyCBindL | _lhsOtyCBindL `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   (case (__tup24) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    { (_chrScopeValBindL,_) | _chrScopeValBindL `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (case ([ acoreBind1CatTy CBindCateg_Plain _patExprItopNm _acorety $
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             acoreLetMerge True CBindCateg_Rec _chrScopeValBindL $
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             _exprIcexpr
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           ]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           ++ _patExprIvalCBindL) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     { _lhsOvalCBindL | _lhsOvalCBindL `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     ( _lhsOallErrSq,_lhsObangEvalL,_lhsOcSubst,_lhsOerrSq,_lhsOffeCBindL,_lhsOffiCBindL,_lhsOgathHiddenExports,_lhsOgathLamMp,_lhsOgathMentrelFilterMp,_lhsOgathTvKiVarMp,_lhsOorphanS,_lhsOpp,_lhsOppAST,_lhsOtrpp,_lhsOtyCBindL,_lhsOvalCBindL) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) })))))))))))))
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    in  sem_Decl_Val_14)) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             { ( sem_Decl_14) | True ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             ( _lhsOgathCnstrMp,_lhsOgathRangeMp,_lhsOintlTyKiGam,_lhsOnoLetQuantTyVarIdS,_lhsOscopeGam,_lhsOtyVarMp,sem_Decl_14) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }))))))))
                                                                                                                                                                                                                                                                                                                                                                                                                                                         in  sem_Decl_Val_13)) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                  { ( sem_Decl_13) | True ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                  ( _lhsOpatTyVarMp,_lhsOpatValGam,sem_Decl_13) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) })))))))
                                                                                                                                                                                                                                                                                                                                                                                                        in  sem_Decl_Val_12)) of
                                                                                                                                                                                                                                                                                                                                                                                                 { ( sem_Decl_12) | True ->
                                                                                                                                                                                                                                                                                                                                                                                                 ( _lhsOchrClassDeclSq,_lhsOchrInstDeclSq,_lhsOgathClDfGam,sem_Decl_12) }) }) }) }) }) }) }) }) }) }) }) })))
                                                                                                                                                                                                                                                                                                                                                               in  sem_Decl_Val_11)) of
                                                                                                                                                                                                                                                                                                                                                        { ( sem_Decl_11) | True ->
                                                                                                                                                                                                                                                                                                                                                        ( _lhsOgathDataGam,_lhsOgathDeclDataGam,_lhsOgathTySigGam,_lhsOgathTySigVarMp,sem_Decl_11) }) }) }) }) }) }) }) }) }) }) }))))
                                                                                                                                                                                                                                                                                                                          in  sem_Decl_Val_10)) of
                                                                                                                                                                                                                                                                                                                   { ( sem_Decl_10) | True ->
                                                                                                                                                                                                                                                                                                                   ( _lhsOpatClGam2,sem_Decl_10) }) }))))))
                                                                                                                                                                                                                                                                                                in  sem_Decl_Val_9)) of
                                                                                                                                                                                                                                                                                         { ( sem_Decl_9) | True ->
                                                                                                                                                                                                                                                                                         ( _lhsOpatClGam1,sem_Decl_9) }) })))
                                                                                                                                                                                                                                                                         in  sem_Decl_Val_8)) of
                                                                                                                                                                                                                                                                  { ( sem_Decl_8) | True ->
                                                                                                                                                                                                                                                                  ( _lhsOgenerDataInfoL,_lhsOgenerDataInfoMp,_lhsOkiVarMp,_lhsOpolVarMp,sem_Decl_8) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }))))))))))
                                                                                                                                                                                          in  sem_Decl_Val_7)) of
                                                                                                                                                                                   { ( sem_Decl_7) | True ->
                                                                                                                                                                                   ( _lhsOpatKiVarMp,_lhsOpatPolGam,sem_Decl_7) }) }) })))))
                                                                                                                                                                in  sem_Decl_Val_6)) of
                                                                                                                                                         { ( sem_Decl_6) | True ->
                                                                                                                                                         ( _lhsOpatTyKiGam,_lhsOtyTyVarMp,sem_Decl_6) }) }) })))))
                                                                                                                                      in  sem_Decl_Val_5)) of
                                                                                                                               { ( sem_Decl_5) | True ->
                                                                                                                               ( _lhsOpatTyGam,sem_Decl_5) }) }))))
                                                                                                              in  sem_Decl_Val_4)) of
                                                                                                       { ( sem_Decl_4) | True ->
                                                                                                       ( _lhsOpredSameScopeCounter,sem_Decl_4) }) }))))
                                                                                      in  sem_Decl_Val_3)) of
                                                                               { ( sem_Decl_3) | True ->
                                                                               ( _lhsOgathTyKiSigGam,sem_Decl_3) }) })))
                                                               in  sem_Decl_Val_2)) of
                                                        { ( sem_Decl_2) | True ->
                                                        ( _lhsOgUniq,_lhsOgathKiSigGam,_lhsOhasInstDecl,sem_Decl_2) }) }) }) }) }) }) }) }) }))))
                        in  sem_Decl_Val_1)) of
                 { ( sem_Decl_1) | True ->
                 ( _lhsOrange,sem_Decl_1) }) }) }) }) })

sem_Decl_Data :: Range ->
                 Bool ->
                 HsName ->
                 T_TyVars ->
                 T_DataConstrs ->
                 (Maybe Int) ->
                 T_Decl

sem_Decl_Data hsrange_ isNewtype_ tyNm_ tyVars_ constrs_ mbGenerInfo_ | hsrange_ `seq` (isNewtype_ `seq` (tyNm_ `seq` (tyVars_ `seq` (constrs_ `seq` (mbGenerInfo_ `seq` (True)))))) =
    (case (constrs_) of
     { ( _constrsIrange,constrs_1) | True ->
         (case (tyVars_) of
          { ( _tyVarsIrange,tyVars_1) | True ->
              (case (rangeUnions [hsrange_, _tyVarsIrange , _constrsIrange
                                                                         ]) of
               { _range | _range `seq` (True) ->
               (case (_range) of
                { _lhsOrange | _lhsOrange `seq` (True) ->
                (case ((let sem_Decl_Data_1 :: T_Decl_1
                            sem_Decl_Data_1 =
                                (\ _lhsIgUniq
                                   _lhsIgathKiSigGam ->
                                     _lhsIgUniq `seq`
                                     (_lhsIgathKiSigGam `seq`
                                      ((case (let __cont = _lhsIgUniq in seq __cont ( case nextUnique __cont of { (__cont, lUniq) -> case nextUnique __cont of { (__cont, lUniq2) -> case nextUnique __cont of { (__cont, lUniq3) -> case nextUnique __cont of { (__cont, lUniq_17_polCtx) -> (__cont,lUniq,lUniq2,lUniq3,lUniq_17_polCtx)}}}} )) of
                                        { __tup29 | __tup29 `seq` (True) ->
                                        (case (__tup29) of
                                         { (_tyVarsOgUniq,_,_,_,_) | _tyVarsOgUniq `seq` (True) ->
                                         (case (tyVars_1 _tyVarsOgUniq) of
                                          { ( _tyVarsIgUniq,tyVars_2) | True ->
                                              (case (_tyVarsIgUniq) of
                                               { _constrsOgUniq | _constrsOgUniq `seq` (True) ->
                                               (case (constrs_1 _constrsOgUniq) of
                                                { ( _constrsIgUniq,constrs_2) | True ->
                                                    (case (_constrsIgUniq) of
                                                     { _lhsOgUniq | _lhsOgUniq `seq` (True) ->
                                                     (case (_lhsIgathKiSigGam) of
                                                      { _lhsOgathKiSigGam | _lhsOgathKiSigGam `seq` (True) ->
                                                      (case (False) of
                                                       { _lhsOhasInstDecl | _lhsOhasInstDecl `seq` (True) ->
                                                       (case ((let sem_Decl_Data_2 :: T_Decl_2
                                                                   sem_Decl_Data_2 =
                                                                       (\ _lhsIkiGam ->
                                                                            _lhsIkiGam `seq`
                                                                            ((case (emptyGam) of
                                                                              { _lhsOgathTyKiSigGam | _lhsOgathTyKiSigGam `seq` (True) ->
                                                                              (case ((let sem_Decl_Data_3 :: T_Decl_3
                                                                                          sem_Decl_Data_3 =
                                                                                              (\ _lhsIlexLev
                                                                                                 _lhsIpredSameScopeCounter ->
                                                                                                   _lhsIlexLev `seq`
                                                                                                   (_lhsIpredSameScopeCounter `seq`
                                                                                                    ((case (_lhsIpredSameScopeCounter) of
                                                                                                      { _lhsOpredSameScopeCounter | _lhsOpredSameScopeCounter `seq` (True) ->
                                                                                                      (case ((let sem_Decl_Data_4 :: T_Decl_4
                                                                                                                  sem_Decl_Data_4 =
                                                                                                                      (\ _lhsIpatTyGam
                                                                                                                         _lhsItyKiSigGam ->
                                                                                                                           _lhsIpatTyGam `seq`
                                                                                                                           (_lhsItyKiSigGam `seq`
                                                                                                                            ((case (case tyKiGamLookupByName tyNm_ _lhsItyKiSigGam of
                                                                                                                                      Nothing -> (Ty_Any,False)
                                                                                                                                      Just i  -> (tkgiKi i,True)) of
                                                                                                                              { __tup28 | __tup28 `seq` (True) ->
                                                                                                                              (case (__tup28) of
                                                                                                                               { (_,_hasKiSig) | _hasKiSig `seq` (True) ->
                                                                                                                               (case (emptyGam) of
                                                                                                                                { _extraTyGam | _extraTyGam `seq` (True) ->
                                                                                                                                (case (mkTGIData (appCon tyNm_) Ty_Any) of
                                                                                                                                 { _dataTgi | _dataTgi `seq` (True) ->
                                                                                                                                 (case (if _hasKiSig  then _lhsIpatTyGam
                                                                                                                                                      else gamAdd tyNm_ _dataTgi _lhsIpatTyGam) of
                                                                                                                                  { _dataPatTyGam | _dataPatTyGam `seq` (True) ->
                                                                                                                                  (case (gamUnion _extraTyGam   _dataPatTyGam) of
                                                                                                                                   { _lhsOpatTyGam | _lhsOpatTyGam `seq` (True) ->
                                                                                                                                   (case ((let sem_Decl_Data_5 :: T_Decl_5
                                                                                                                                               sem_Decl_Data_5 =
                                                                                                                                                   (\ _lhsIpatTyKiGam
                                                                                                                                                      _lhsItyGam
                                                                                                                                                      _lhsItyTyVarMp ->
                                                                                                                                                        _lhsIpatTyKiGam `seq`
                                                                                                                                                        (_lhsItyGam `seq`
                                                                                                                                                         (_lhsItyTyVarMp `seq`
                                                                                                                                                          ((case (__tup29) of
                                                                                                                                                            { (_,_lUniq,_,_,_) | _lUniq `seq` (True) ->
                                                                                                                                                            (case (__tup28) of
                                                                                                                                                             { (_sigKi,_) | _sigKi `seq` (True) ->
                                                                                                                                                             (case (_sigKi) of
                                                                                                                                                              { _knKi | _knKi `seq` (True) ->
                                                                                                                                                              (case (emptyGam) of
                                                                                                                                                               { _extraTyKiGam | _extraTyKiGam `seq` (True) ->
                                                                                                                                                               (case (TyKiGamInfo (tyEnsureNonAny _lUniq _knKi)) of
                                                                                                                                                                { _dataTkgi | _dataTkgi `seq` (True) ->
                                                                                                                                                                (case (if _hasKiSig  then _lhsIpatTyKiGam
                                                                                                                                                                                     else tyKiGamNameSingleton tyNm_ _dataTkgi `gamUnion` _lhsIpatTyKiGam) of
                                                                                                                                                                 { _dataPatTyKiGam | _dataPatTyKiGam `seq` (True) ->
                                                                                                                                                                 (case (gamUnion _extraTyKiGam _dataPatTyKiGam) of
                                                                                                                                                                  { _lhsOpatTyKiGam | _lhsOpatTyKiGam `seq` (True) ->
                                                                                                                                                                  (case (_lhsItyTyVarMp) of
                                                                                                                                                                   { _lhsOtyTyVarMp | _lhsOtyTyVarMp `seq` (True) ->
                                                                                                                                                                   (case ((let sem_Decl_Data_6 :: T_Decl_6
                                                                                                                                                                               sem_Decl_Data_6 =
                                                                                                                                                                                   (\ _lhsIpatKiVarMp
                                                                                                                                                                                      _lhsIpatPolGam
                                                                                                                                                                                      _lhsItyKiGam ->
                                                                                                                                                                                        _lhsIpatKiVarMp `seq`
                                                                                                                                                                                        (_lhsIpatPolGam `seq`
                                                                                                                                                                                         (_lhsItyKiGam `seq`
                                                                                                                                                                                          ((case (_lhsItyKiGam) of
                                                                                                                                                                                            { _tyVarsOtyKiGam | _tyVarsOtyKiGam `seq` (True) ->
                                                                                                                                                                                            (case (__tup29) of
                                                                                                                                                                                             { (_,_,_lUniq2,_,_) | _lUniq2 `seq` (True) ->
                                                                                                                                                                                             (case (emptyGam) of
                                                                                                                                                                                              { _tyVarsOtyGam | _tyVarsOtyGam `seq` (True) ->
                                                                                                                                                                                              (case (tyVars_2 _tyVarsOtyGam) of
                                                                                                                                                                                               { ( _tyVarsItyGam,tyVars_3) | True ->
                                                                                                                                                                                                   (case (tyVars_3 _tyVarsOtyKiGam) of
                                                                                                                                                                                                    { ( _tyVarsIgathTyVarPolGam,_tyVarsIintlTyKiGam,_tyVarsIkiL,_tyVarsIpolVarL,_tyVarsItyKiGam,_tyVarsItyL,tyVars_4) | True ->
                                                                                                                                                                                                        (case (fitsIn  strongFIOpts defaultFIEnv _lUniq2 _lhsIpatKiVarMp
                                                                                                                                                                                                                       (_tyVarsIkiL `appArr` kiStar) (tkgiKi _dataTkgi)) of
                                                                                                                                                                                                         { _fo_ | _fo_ `seq` (True) ->
                                                                                                                                                                                                         (case (foVarMp _fo_ `varUpd` _lhsIpatKiVarMp) of
                                                                                                                                                                                                          { _lhsOpatKiVarMp | _lhsOpatKiVarMp `seq` (True) ->
                                                                                                                                                                                                          (case (__tup29) of
                                                                                                                                                                                                           { (_,_,_,_,_lUniq_17_polCtx) | _lUniq_17_polCtx `seq` (True) ->
                                                                                                                                                                                                           (case (mkPolVar _lUniq_17_polCtx) of
                                                                                                                                                                                                            { _polCtxVar | _polCtxVar `seq` (True) ->
                                                                                                                                                                                                            (case (_tyVarsIpolVarL `appArr` _polCtxVar) of
                                                                                                                                                                                                             { _polSig | _polSig `seq` (True) ->
                                                                                                                                                                                                             (case (gamAdd tyNm_ (mkPGI _polSig) _lhsIpatPolGam) of
                                                                                                                                                                                                              { _lhsOpatPolGam | _lhsOpatPolGam `seq` (True) ->
                                                                                                                                                                                                              (case ((let sem_Decl_Data_7 :: T_Decl_7
                                                                                                                                                                                                                          sem_Decl_Data_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 (_lhsIpolVarMp) of
                                                                                                                                                                                                                                            { _constrsOpolVarMp | _constrsOpolVarMp `seq` (True) ->
                                                                                                                                                                                                                                            (case (tyNm_ `appConApp` _tyVarsItyL) of
                                                                                                                                                                                                                                             { _dataTy | _dataTy `seq` (True) ->
                                                                                                                                                                                                                                             (case (_dataTy) of
                                                                                                                                                                                                                                              { _constrsOdataTy | _constrsOdataTy `seq` (True) ->
                                                                                                                                                                                                                                              (case (gamPushGam _tyVarsItyGam _lhsItyGam) of
                                                                                                                                                                                                                                               { _constrsOtyGam | _constrsOtyGam `seq` (True) ->
                                                                                                                                                                                                                                               (case (gamPushGam _tyVarsIgathTyVarPolGam _lhsIpolGam) of
                                                                                                                                                                                                                                                { _constrsOpolGam | _constrsOpolGam `seq` (True) ->
                                                                                                                                                                                                                                                (case (_polCtxVar) of
                                                                                                                                                                                                                                                 { _constrsOknPolCtx | _constrsOknPolCtx `seq` (True) ->
                                                                                                                                                                                                                                                 (case (constrs_2 _constrsOdataTy _constrsOknPolCtx _constrsOpolGam _constrsOpolVarMp _constrsOtyGam) of
                                                                                                                                                                                                                                                  { ( _constrsIdataAltTyL,_constrsIgathMaxArity,_constrsIpolVarMp,constrs_3) | True ->
                                                                                                                                                                                                                                                      (case (recSum _constrsIdataAltTyL) of
                                                                                                                                                                                                                                                       { _dataAltTy | _dataAltTy `seq` (True) ->
                                                                                                                                                                                                                                                       (case (_dataAltTy) of
                                                                                                                                                                                                                                                        { _constrsOdataAltTy | _constrsOdataAltTy `seq` (True) ->
                                                                                                                                                                                                                                                        (case (_constrsIgathMaxArity) of
                                                                                                                                                                                                                                                         { _constrsOmaxArity | _constrsOmaxArity `seq` (True) ->
                                                                                                                                                                                                                                                         (case (tyNm_) of
                                                                                                                                                                                                                                                          { _constrsOtyNm | _constrsOtyNm `seq` (True) ->
                                                                                                                                                                                                                                                          (case (map (panicJust "EH.InferData.Decl.Data.tyMbVar" . tyMbVar) _tyVarsItyL) of
                                                                                                                                                                                                                                                           { _dataTyVarIdL | _dataTyVarIdL `seq` (True) ->
                                                                                                                                                                                                                                                           (case (foTy _fo_) of
                                                                                                                                                                                                                                                            { _dataKi | _dataKi `seq` (True) ->
                                                                                                                                                                                                                                                            (case (_lhsIkiVarMp) of
                                                                                                                                                                                                                                                             { _constrsOkiVarMp | _constrsOkiVarMp `seq` (True) ->
                                                                                                                                                                                                                                                             (case (__tup29) of
                                                                                                                                                                                                                                                              { (_,_,_,_lUniq3,_) | _lUniq3 `seq` (True) ->
                                                                                                                                                                                                                                                              (case (gamPushGam  (tyKiGamInst1Exists _lUniq3 (_lhsIkiVarMp `varUpd` _tyVarsItyKiGam))
                                                                                                                                                                                                                                                                                 _lhsItyKiGam) of
                                                                                                                                                                                                                                                               { _constrsOtyKiGam | _constrsOtyKiGam `seq` (True) ->
                                                                                                                                                                                                                                                               (case (constrs_3 _constrsOdataAltTy _constrsOkiVarMp _constrsOmaxArity _constrsOtyKiGam _constrsOtyNm) of
                                                                                                                                                                                                                                                                { ( _constrsIdataAltForNewType,_constrsIdataConstrNmL,_constrsIdataConstrTagMp,_constrsIintlTyKiGam,_constrsIkiVarMp,constrs_4) | True ->
                                                                                                                                                                                                                                                                    (case (if isJust mbGenerInfo_
                                                                                                                                                                                                                                                                           then let i = ( (tyNm_, _dataTyVarIdL, _dataKi)
                                                                                                                                                                                                                                                                                        , [ ( dtiCTag dti, dtiFldTyL dti )
                                                                                                                                                                                                                                                                                          | (c,cty) <- snd $ tyRecExts _dataAltTy
                                                                                                                                                                                                                                                                                          , let dti = panicJust "Generics.Decl.Data.dataConstrTagMp" $ Map.lookup c _constrsIdataConstrTagMp
                                                                                                                                                                                                                                                                                          ]
                                                                                                                                                                                                                                                                                        , _lhsIpredScope
                                                                                                                                                                                                                                                                                        , fromJust mbGenerInfo_
                                                                                                                                                                                                                                                                                        )
                                                                                                                                                                                                                                                                                in  if ehcOptIsUnderDev UnderDev_NameAnalysis _lhsIopts
                                                                                                                                                                                                                                                                                    then ([] , Map.singleton tyNm_ i)
                                                                                                                                                                                                                                                                                    else ([i], Map.empty            )
                                                                                                                                                                                                                                                                           else ([], Map.empty)) of
                                                                                                                                                                                                                                                                     { __tup27 | __tup27 `seq` (True) ->
                                                                                                                                                                                                                                                                     (case (__tup27) of
                                                                                                                                                                                                                                                                      { (_generDataInfoL,_) | _generDataInfoL `seq` (True) ->
                                                                                                                                                                                                                                                                      (case (_generDataInfoL) of
                                                                                                                                                                                                                                                                       { _lhsOgenerDataInfoL | _lhsOgenerDataInfoL `seq` (True) ->
                                                                                                                                                                                                                                                                       (case (__tup27) of
                                                                                                                                                                                                                                                                        { (_,_generDataInfoMpNew) | _generDataInfoMpNew `seq` (True) ->
                                                                                                                                                                                                                                                                        (case (_generDataInfoMpNew `Map.union` _lhsIgenerDataInfoMp) of
                                                                                                                                                                                                                                                                         { _lhsOgenerDataInfoMp | _lhsOgenerDataInfoMp `seq` (True) ->
                                                                                                                                                                                                                                                                         (case (_constrsIkiVarMp) of
                                                                                                                                                                                                                                                                          { _lhsOkiVarMp | _lhsOkiVarMp `seq` (True) ->
                                                                                                                                                                                                                                                                          (case (_constrsIpolVarMp) of
                                                                                                                                                                                                                                                                           { _lhsOpolVarMp | _lhsOpolVarMp `seq` (True) ->
                                                                                                                                                                                                                                                                           (case ((let sem_Decl_Data_8 :: T_Decl_8
                                                                                                                                                                                                                                                                                       sem_Decl_Data_8 =
                                                                                                                                                                                                                                                                                           (\ _lhsIpatClGam1 ->
                                                                                                                                                                                                                                                                                                _lhsIpatClGam1 `seq`
                                                                                                                                                                                                                                                                                                ((case (_lhsIpatClGam1) of
                                                                                                                                                                                                                                                                                                  { _lhsOpatClGam1 | _lhsOpatClGam1 `seq` (True) ->
                                                                                                                                                                                                                                                                                                  (case ((let sem_Decl_Data_9 :: T_Decl_9
                                                                                                                                                                                                                                                                                                              sem_Decl_Data_9 =
                                                                                                                                                                                                                                                                                                                  (\ _lhsIfinKiVarMp
                                                                                                                                                                                                                                                                                                                     _lhsIfinTyKiGam
                                                                                                                                                                                                                                                                                                                     _lhsIpatClGam2
                                                                                                                                                                                                                                                                                                                     _lhsItyTyTySigFreeTvarS ->
                                                                                                                                                                                                                                                                                                                       _lhsIfinKiVarMp `seq`
                                                                                                                                                                                                                                                                                                                       (_lhsIfinTyKiGam `seq`
                                                                                                                                                                                                                                                                                                                        (_lhsIpatClGam2 `seq`
                                                                                                                                                                                                                                                                                                                         (_lhsItyTyTySigFreeTvarS `seq`
                                                                                                                                                                                                                                                                                                                          ((case (_lhsIpatClGam2) of
                                                                                                                                                                                                                                                                                                                            { _lhsOpatClGam2 | _lhsOpatClGam2 `seq` (True) ->
                                                                                                                                                                                                                                                                                                                            (case ((let sem_Decl_Data_10 :: T_Decl_10
                                                                                                                                                                                                                                                                                                                                        sem_Decl_Data_10 =
                                                                                                                                                                                                                                                                                                                                            (\ _lhsIclGam
                                                                                                                                                                                                                                                                                                                                               _lhsIgathDataGam ->
                                                                                                                                                                                                                                                                                                                                                 _lhsIclGam `seq`
                                                                                                                                                                                                                                                                                                                                                 (_lhsIgathDataGam `seq`
                                                                                                                                                                                                                                                                                                                                                  ((case (_lhsIgathDataGam) of
                                                                                                                                                                                                                                                                                                                                                    { _lhsOgathDataGam | _lhsOgathDataGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                    (case (emptyGam) of
                                                                                                                                                                                                                                                                                                                                                     { _extraDataGam | _extraDataGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                     (case (mkDGI tyNm_
                                                                                                                                                                                                                                                                                                                                                                                              ([_dataTy] `appArr` _dataAltTy)
                                                                                                                                                                                                                                                                                                                                                                                              (tkgiKi _dataTkgi)
                                                                                                                                                                                                                                                                                                                                                                                              _constrsIdataConstrNmL _constrsIdataConstrTagMp
                                                                                                                                                                                                                                                                                                                                                                  (if isNewtype_
                                                                                                                                                                                                                                                                                                                                                                   then DataGamInfoVariant_Newtype $ mkTyLam _dataTyVarIdL _constrsIdataAltForNewType
                                                                                                                                                                                                                                                                                                                                                                   else DataGamInfoVariant_Plain
                                                                                                                                                                                                                                                                                                                                                                  )
                                                                                                                                                                                                                                                                                                                                                                  mbGenerInfo_) of
                                                                                                                                                                                                                                                                                                                                                      { _dgi | _dgi `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                      (case (gamUnion _extraDataGam $ gamSingleton tyNm_ _dgi) of
                                                                                                                                                                                                                                                                                                                                                       { _lhsOgathDeclDataGam | _lhsOgathDeclDataGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                       (case (emptyGam) of
                                                                                                                                                                                                                                                                                                                                                        { _lhsOgathTySigGam | _lhsOgathTySigGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                        (case (emptyVarMp) of
                                                                                                                                                                                                                                                                                                                                                         { _lhsOgathTySigVarMp | _lhsOgathTySigVarMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                         (case ((let sem_Decl_Data_11 :: T_Decl_11
                                                                                                                                                                                                                                                                                                                                                                     sem_Decl_Data_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_Decl_Data_12 :: T_Decl_12
                                                                                                                                                                                                                                                                                                                                                                                              sem_Decl_Data_12 =
                                                                                                                                                                                                                                                                                                                                                                                                  (\ _lhsIpatTyVarMp
                                                                                                                                                                                                                                                                                                                                                                                                     _lhsIpatValGam
                                                                                                                                                                                                                                                                                                                                                                                                     _lhsItvKiVarMp
                                                                                                                                                                                                                                                                                                                                                                                                     _lhsItySigGam
                                                                                                                                                                                                                                                                                                                                                                                                     _lhsItySigVarMp ->
                                                                                                                                                                                                                                                                                                                                                                                                       _lhsIpatTyVarMp `seq`
                                                                                                                                                                                                                                                                                                                                                                                                       (_lhsIpatValGam `seq`
                                                                                                                                                                                                                                                                                                                                                                                                        (_lhsItvKiVarMp `seq`
                                                                                                                                                                                                                                                                                                                                                                                                         (_lhsItySigGam `seq`
                                                                                                                                                                                                                                                                                                                                                                                                          (_lhsItySigVarMp `seq`
                                                                                                                                                                                                                                                                                                                                                                                                           ((case (_lhsItvKiVarMp) of
                                                                                                                                                                                                                                                                                                                                                                                                             { _constrsOtvKiVarMp | _constrsOtvKiVarMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                             (case (_lhsIpatTyVarMp) of
                                                                                                                                                                                                                                                                                                                                                                                                              { _constrsOpatTyVarMp | _constrsOpatTyVarMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                              (case (_lhsIfinTyKiGam) of
                                                                                                                                                                                                                                                                                                                                                                                                               { _constrsOfinTyKiGam | _constrsOfinTyKiGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                               (case (_lhsIpatValGam) of
                                                                                                                                                                                                                                                                                                                                                                                                                { _constrsOpatValGam | _constrsOpatValGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                (case (constrs_4 _constrsOfinTyKiGam _constrsOpatTyVarMp _constrsOpatValGam _constrsOtvKiVarMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                 { ( _constrsIfldSelGam,_constrsIfldUpdGam,_constrsIgathCnstrMp,_constrsIgathRangeMp,_constrsIpatTyVarMp,_constrsIpatValGam,constrs_5) | True ->
                                                                                                                                                                                                                                                                                                                                                                                                                     (case (_constrsIpatTyVarMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                      { _lhsOpatTyVarMp | _lhsOpatTyVarMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                      (case (gamUnions
                                                                                                                                                                                                                                                                                                                                                                                                                               [ gamNoDups _constrsIfldSelGam
                                                                                                                                                                                                                                                                                                                                                                                                                               , gamNoDups _constrsIfldUpdGam
                                                                                                                                                                                                                                                                                                                                                                                                                               , _constrsIpatValGam
                                                                                                                                                                                                                                                                                                                                                                                                                               ]) of
                                                                                                                                                                                                                                                                                                                                                                                                                       { _lhsOpatValGam | _lhsOpatValGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                       (case ((let sem_Decl_Data_13 :: T_Decl_13
                                                                                                                                                                                                                                                                                                                                                                                                                                   sem_Decl_Data_13 =
                                                                                                                                                                                                                                                                                                                                                                                                                                       (\ _lhsIchrStore
                                                                                                                                                                                                                                                                                                                                                                                                                                          _lhsIclDfGam
                                                                                                                                                                                                                                                                                                                                                                                                                                          _lhsItyTyGlobFreeTvarS
                                                                                                                                                                                                                                                                                                                                                                                                                                          _lhsItyVarMp
                                                                                                                                                                                                                                                                                                                                                                                                                                          _lhsIvalGam
                                                                                                                                                                                                                                                                                                                                                                                                                                          _lhsIvalTyGlobFreeTvarS ->
                                                                                                                                                                                                                                                                                                                                                                                                                                            _lhsIchrStore `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                                            (_lhsIclDfGam `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                                             (_lhsItyTyGlobFreeTvarS `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                                              (_lhsItyVarMp `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                                               (_lhsIvalGam `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                                                (_lhsIvalTyGlobFreeTvarS `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                                                 ((case (_constrsIgathCnstrMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                   { _lhsOgathCnstrMp | _lhsOgathCnstrMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                   (case (_constrsIgathRangeMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                    { _lhsOgathRangeMp | _lhsOgathRangeMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                    (case (_tyVarsIintlTyKiGam `gamUnion` _constrsIintlTyKiGam) 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_Decl_Data_14 :: T_Decl_14
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    sem_Decl_Data_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 (_lhsIvalTyGlobFreeTvarS) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         { _constrsOvalTyGlobFreeTvarS | _constrsOvalTyGlobFreeTvarS `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         (case (_lhsIvalGam) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          { _constrsOvalGam | _constrsOvalGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          (case (_lhsItyTyTySigFreeTvarS) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           { _constrsOtyTyTySigFreeTvarS | _constrsOtyTyTySigFreeTvarS `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           (case (_lhsItyTyGlobFreeTvarS) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            { _constrsOtyTyGlobFreeTvarS | _constrsOtyTyGlobFreeTvarS `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (case (_lhsItyKiGlobFreeTvarS) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             { _constrsOtyKiGlobFreeTvarS | _constrsOtyKiGlobFreeTvarS `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             (case (_lhsItr) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              { _constrsOtr | _constrsOtr `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              (case (_lhsIsysfEnv) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               { _constrsOsysfEnv | _constrsOsysfEnv `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               (case (_lhsIrangeMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                { _constrsOrangeMp | _constrsOrangeMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (case (_lhsIpredScope) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 { _constrsOpredScope | _constrsOpredScope `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 (case (_lhsIopts) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  { _constrsOopts | _constrsOopts `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (case (_lhsImoduleNm) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   { _constrsOmoduleNm | _constrsOmoduleNm `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   (case (_lhsIlexLev) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    { _constrsOlexLev | _constrsOlexLev `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (case (_lhsIkiGam) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     { _constrsOkiGam | _constrsOkiGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     (case (_lhsIfinTyVarMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      { _constrsOfinTyVarMp | _constrsOfinTyVarMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      (case (_lhsIfinKiVarMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       { _constrsOfinKiVarMp | _constrsOfinKiVarMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       (case (_lhsIclGam) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        { _constrsOclGam | _constrsOclGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (case (_lhsIclDfGam) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         { _constrsOclDfGam | _constrsOclDfGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         (case (_lhsIchrStore) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          { _constrsOchrStore | _constrsOchrStore `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          (case (_lhsIchrScopeBindMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           { _constrsOchrScopeBindMp | _constrsOchrScopeBindMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           (case (_lhsIchrEvidBindMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            { _constrsOchrEvidBindMp | _constrsOchrEvidBindMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (case (isNewtype_) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             { _constrsOisNewtype | _constrsOisNewtype `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             (case (constrs_5 _constrsOchrEvidBindMp _constrsOchrScopeBindMp _constrsOchrStore _constrsOclDfGam _constrsOclGam _constrsOfinKiVarMp _constrsOfinTyVarMp _constrsOisNewtype _constrsOkiGam _constrsOlexLev _constrsOmoduleNm _constrsOopts _constrsOpredScope _constrsOrangeMp _constrsOsysfEnv _constrsOtr _constrsOtyKiGlobFreeTvarS _constrsOtyTyGlobFreeTvarS _constrsOtyTyTySigFreeTvarS _constrsOvalGam _constrsOvalTyGlobFreeTvarS) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              { ( _constrsIallErrSq,_constrsIerrSq,_constrsIffeCBindL,_constrsIffiCBindL,_constrsIgathMentrelFilterMp,_constrsIgathTvKiVarMp,_constrsIpp,_constrsIppAST,_constrsIppL,_constrsItrpp,_constrsItyCBindL,_constrsIvalCBindL) | True ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (case (_lhsIvalTyGlobFreeTvarS) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   { _tyVarsOvalTyGlobFreeTvarS | _tyVarsOvalTyGlobFreeTvarS `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   (case (_lhsItyTyTySigFreeTvarS) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    { _tyVarsOtyTyTySigFreeTvarS | _tyVarsOtyTyTySigFreeTvarS `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (case (_lhsItyTyGlobFreeTvarS) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     { _tyVarsOtyTyGlobFreeTvarS | _tyVarsOtyTyGlobFreeTvarS `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     (case (_lhsItyKiGlobFreeTvarS) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      { _tyVarsOtyKiGlobFreeTvarS | _tyVarsOtyKiGlobFreeTvarS `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      (case (_lhsItr) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       { _tyVarsOtr | _tyVarsOtr `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       (case (_lhsIsysfEnv) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        { _tyVarsOsysfEnv | _tyVarsOsysfEnv `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (case (_lhsIopts) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         { _tyVarsOopts | _tyVarsOopts `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         (case (_lhsImoduleNm) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          { _tyVarsOmoduleNm | _tyVarsOmoduleNm `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          (case (_lhsIfinTyVarMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           { _tyVarsOfinTyVarMp | _tyVarsOfinTyVarMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           (case (_lhsIfinTyKiGam) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            { _tyVarsOfinTyKiGam | _tyVarsOfinTyKiGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (case (_lhsIfinKiVarMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             { _tyVarsOfinKiVarMp | _tyVarsOfinKiVarMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             (case (tyVars_4 _tyVarsOfinKiVarMp _tyVarsOfinTyKiGam _tyVarsOfinTyVarMp _tyVarsOmoduleNm _tyVarsOopts _tyVarsOsysfEnv _tyVarsOtr _tyVarsOtyKiGlobFreeTvarS _tyVarsOtyTyGlobFreeTvarS _tyVarsOtyTyTySigFreeTvarS _tyVarsOvalTyGlobFreeTvarS) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              { ( _tyVarsIallErrSq,_tyVarsIerrSq,_tyVarsIgathMentrelFilterMp,_tyVarsInmL,_tyVarsIpp,_tyVarsIppAST,_tyVarsIppL,_tyVarsItrpp) | True ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (case (_tyVarsIallErrSq `Seq.union` _constrsIallErrSq) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   { _lhsOallErrSq | _lhsOallErrSq `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   (case ([]) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    { _lhsObangEvalL | _lhsObangEvalL `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (case (_lhsIcSubst) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     { _lhsOcSubst | _lhsOcSubst `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     (case (defaultFIEnv
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                { feTyGam = _lhsItyGam
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                , feEHCOpts = _lhsIopts
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                , feDataGam = _lhsIdataGam
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                , fePolGam = _lhsIpolGam
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                , feRange = _range
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      { _fe | _fe `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      (case (let  ft = gamToOnlyDups _constrsIfldSelGam
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  wrong tl = foHasErrs fo
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           where fo = fitsInFold opts _fe uidStart _lhsIfinTyVarMp $ map (appUnArrRes . vgiTy) $ tl
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 (tlvars,tl') = unzip [ (varFreeSet t', t') | t <- tl, let t' = appUnArrRes (vgiTy t) ]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 opts = unifyFIOpts { fioDontBind = Set.unions tlvars }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  nms = [ f | (f,tl) <- ft, wrong tl ]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             in   if null nms then [] else [rngLift _range Err_InconsistentIntros "data field" nms]) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       { _inconsistFldErrs | _inconsistFldErrs `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       (case ((if isNewtype_ then "newtype" else "data")
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              >#< tyNm_ >#< ppSpaced _tyVarsIppL
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              >#< "=" >#< ppBlockWithStrings "" "" "| " _constrsIppL) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        { _pp | _pp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (case (rngLift _range mkNestErr' _pp [ _tyVarsIerrSq, _constrsIerrSq
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             , foErrSq _fo_
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             , Seq.fromList _inconsistFldErrs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             ]) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         { _lhsOerrSq | _lhsOerrSq `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         (case (_constrsIffeCBindL) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          { _lhsOffeCBindL | _lhsOffeCBindL `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          (case (_constrsIffiCBindL) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           { _lhsOffiCBindL | _lhsOffiCBindL `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           (case (Seq.empty) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            { _lhsOgathHiddenExports | _lhsOgathHiddenExports `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (case (Map.empty) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             { _lhsOgathLamMp | _lhsOgathLamMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             (case (_tyVarsIgathMentrelFilterMp `mentrelFilterMpUnion` _constrsIgathMentrelFilterMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              { _lhsOgathMentrelFilterMp | _lhsOgathMentrelFilterMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              (case (_constrsIgathTvKiVarMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               { _lhsOgathTvKiVarMp | _lhsOgathTvKiVarMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               (case (Set.empty) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                { _lhsOorphanS | _lhsOorphanS `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (case (_pp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 { _lhsOpp | _lhsOpp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 (case (trppEmpty) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  { _trppHere | _trppHere `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (case (ppNestTrPP _lhsIopts ["Decl","Data"] [ppTrNm tyNm_] [_tyVarsIppAST,_constrsIppAST] _trppHere) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   { _lhsOppAST | _lhsOppAST `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   (case (_tyVarsItrpp >< _constrsItrpp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    { _lhsOtrpp | _lhsOtrpp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (case (_constrsItyCBindL) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     { _lhsOtyCBindL | _lhsOtyCBindL `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     (case ((emptyRCEEnv _lhsIopts) { rceValGam = _lhsIvalGam, rceDataGam = _lhsIdataGam, rceTyVarMp = _lhsIfinTyVarMp }) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      { _rceEnv | _rceEnv `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      (case (let (xn1:xn2:_) = hsnLclSupply
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 tgSels f i = [ (t,[(f,acoreTyErr $ "EH.ToCore.Decl.Data.tgSels:" ++ show f,        fldInt o)],Nothing,acoreVar f) | (t,o) <- Map.toList $ dficInTagMp i ]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 ty1 f = valGamLookupTyDefault f _lhsIfinValGam
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 ty2 t = SysF.ty2TyC _lhsIopts _lhsIsysfEnv t
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             in  if isNewtype_
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 then [ [ acoreBind1Ty f (ty2 $ ty1 f) (acoreVar $ ehcOptBuiltin _lhsIopts ehbnId)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | (f,i) <- Map.toList $ dgiFldInConstrMp _dgi
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ] ]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 else [ [ acoreBind1Ty f (ty2 t)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (acoreLamTy [(xn1,acoreTyErr "EH.ToCore.Decl.Data.")]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              (acoreSatSelsCasesTy (rceUpdEnv (acoreVar en) _rceEnv) (Just (xn2,ty2 $ appUnArrArg t)) (acoreVar xn1) tg))
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ++ (if isSaturated then [] else [ acoreBind1Ty en (acoreTyErr $ "EH.ToCore.Decl.Data.en: " ++ show en) (acoreBuiltinError _lhsIopts ("has no field selection '" ++ show f ++ "'")) ])
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | (f,i) <- Map.toList $ dgiFldInConstrMp _dgi
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      , let en = hsnUniqifyStr HsNameUniqifier_New "datafield_sel_error" f
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            tg = tgSels f i
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            isSaturated = length tg == Map.size (dgiConstrTagMp _dgi)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            t = ty1 f
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ]) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       { _fldSelCBindL | _fldSelCBindL `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       (case (concat _fldSelCBindL ++ _constrsIvalCBindL) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        { _lhsOvalCBindL | _lhsOvalCBindL `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ( _lhsOallErrSq,_lhsObangEvalL,_lhsOcSubst,_lhsOerrSq,_lhsOffeCBindL,_lhsOffiCBindL,_lhsOgathHiddenExports,_lhsOgathLamMp,_lhsOgathMentrelFilterMp,_lhsOgathTvKiVarMp,_lhsOorphanS,_lhsOpp,_lhsOppAST,_lhsOtrpp,_lhsOtyCBindL,_lhsOvalCBindL) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) })))))))))))))
                                                                                                                                                                                                                                                                                                                                                                                                                                                                in  sem_Decl_Data_14)) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                         { ( sem_Decl_14) | True ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                         ( _lhsOgathCnstrMp,_lhsOgathRangeMp,_lhsOintlTyKiGam,_lhsOnoLetQuantTyVarIdS,_lhsOscopeGam,_lhsOtyVarMp,sem_Decl_14) }) }) }) }) }) }) }))))))))
                                                                                                                                                                                                                                                                                                                                                                                                                               in  sem_Decl_Data_13)) of
                                                                                                                                                                                                                                                                                                                                                                                                                        { ( sem_Decl_13) | True ->
                                                                                                                                                                                                                                                                                                                                                                                                                        ( _lhsOpatTyVarMp,_lhsOpatValGam,sem_Decl_13) }) }) }) }) }) }) }) })))))))
                                                                                                                                                                                                                                                                                                                                                                                          in  sem_Decl_Data_12)) of
                                                                                                                                                                                                                                                                                                                                                                                   { ( sem_Decl_12) | True ->
                                                                                                                                                                                                                                                                                                                                                                                   ( _lhsOchrClassDeclSq,_lhsOchrInstDeclSq,_lhsOgathClDfGam,sem_Decl_12) }) }) }) })))
                                                                                                                                                                                                                                                                                                                                                                 in  sem_Decl_Data_11)) of
                                                                                                                                                                                                                                                                                                                                                          { ( sem_Decl_11) | True ->
                                                                                                                                                                                                                                                                                                                                                          ( _lhsOgathDataGam,_lhsOgathDeclDataGam,_lhsOgathTySigGam,_lhsOgathTySigVarMp,sem_Decl_11) }) }) }) }) }) }) }))))
                                                                                                                                                                                                                                                                                                                                    in  sem_Decl_Data_10)) of
                                                                                                                                                                                                                                                                                                                             { ( sem_Decl_10) | True ->
                                                                                                                                                                                                                                                                                                                             ( _lhsOpatClGam2,sem_Decl_10) }) }))))))
                                                                                                                                                                                                                                                                                                          in  sem_Decl_Data_9)) of
                                                                                                                                                                                                                                                                                                   { ( sem_Decl_9) | True ->
                                                                                                                                                                                                                                                                                                   ( _lhsOpatClGam1,sem_Decl_9) }) })))
                                                                                                                                                                                                                                                                                   in  sem_Decl_Data_8)) of
                                                                                                                                                                                                                                                                            { ( sem_Decl_8) | True ->
                                                                                                                                                                                                                                                                            ( _lhsOgenerDataInfoL,_lhsOgenerDataInfoMp,_lhsOkiVarMp,_lhsOpolVarMp,sem_Decl_8) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }))))))))))
                                                                                                                                                                                                                      in  sem_Decl_Data_7)) of
                                                                                                                                                                                                               { ( sem_Decl_7) | True ->
                                                                                                                                                                                                               ( _lhsOpatKiVarMp,_lhsOpatPolGam,sem_Decl_7) }) }) }) }) }) }) }) }) }) }) }) })))))
                                                                                                                                                                           in  sem_Decl_Data_6)) of
                                                                                                                                                                    { ( sem_Decl_6) | True ->
                                                                                                                                                                    ( _lhsOpatTyKiGam,_lhsOtyTyVarMp,sem_Decl_6) }) }) }) }) }) }) }) }) })))))
                                                                                                                                           in  sem_Decl_Data_5)) of
                                                                                                                                    { ( sem_Decl_5) | True ->
                                                                                                                                    ( _lhsOpatTyGam,sem_Decl_5) }) }) }) }) }) }) }))))
                                                                                                              in  sem_Decl_Data_4)) of
                                                                                                       { ( sem_Decl_4) | True ->
                                                                                                       ( _lhsOpredSameScopeCounter,sem_Decl_4) }) }))))
                                                                                      in  sem_Decl_Data_3)) of
                                                                               { ( sem_Decl_3) | True ->
                                                                               ( _lhsOgathTyKiSigGam,sem_Decl_3) }) })))
                                                               in  sem_Decl_Data_2)) of
                                                        { ( sem_Decl_2) | True ->
                                                        ( _lhsOgUniq,_lhsOgathKiSigGam,_lhsOhasInstDecl,sem_Decl_2) }) }) }) }) }) }) }) }) }))))
                        in  sem_Decl_Data_1)) of
                 { ( sem_Decl_1) | True ->
                 ( _lhsOrange,sem_Decl_1) }) }) }) }) })

sem_Decl_KiSig :: Range ->
                  HsName ->
                  T_KiExpr ->
                  T_Decl

sem_Decl_KiSig hsrange_ nm_ kiExpr_ | hsrange_ `seq` (nm_ `seq` (kiExpr_ `seq` (True))) =
    (case (kiExpr_) of
     { ( _kiExprIrange,kiExpr_1) | True ->
         (case (rangeUnions [hsrange_, _kiExprIrange , _kiExprIrange]) of
          { _range | _range `seq` (True) ->
          (case (_range) of
           { _lhsOrange | _lhsOrange `seq` (True) ->
           (case ((let sem_Decl_KiSig_1 :: T_Decl_1
                       sem_Decl_KiSig_1 =
                           (\ _lhsIgUniq
                              _lhsIgathKiSigGam ->
                                _lhsIgUniq `seq`
                                (_lhsIgathKiSigGam `seq`
                                 ((case (_lhsIgUniq) of
                                   { _kiExprOgUniq | _kiExprOgUniq `seq` (True) ->
                                   (case (kiExpr_1 _kiExprOgUniq) of
                                    { ( _kiExprIgUniq,kiExpr_2) | True ->
                                        (case (_kiExprIgUniq) of
                                         { _lhsOgUniq | _lhsOgUniq `seq` (True) ->
                                         (case (gamAdd nm_ (mkTGI (appCon nm_)) _lhsIgathKiSigGam) of
                                          { _lhsOgathKiSigGam | _lhsOgathKiSigGam `seq` (True) ->
                                          (case (False) of
                                           { _lhsOhasInstDecl | _lhsOhasInstDecl `seq` (True) ->
                                           (case ((let sem_Decl_KiSig_2 :: T_Decl_2
                                                       sem_Decl_KiSig_2 =
                                                           (\ _lhsIkiGam ->
                                                                _lhsIkiGam `seq`
                                                                ((case (_lhsIkiGam) of
                                                                  { _kiExprOkiGam | _kiExprOkiGam `seq` (True) ->
                                                                  (case (kiExpr_2 _kiExprOkiGam) of
                                                                   { ( _kiExprIki,_kiExprIkiGam,kiExpr_3) | True ->
                                                                       (case (tyKiQuantify True (const False) _kiExprIki) of
                                                                        { _sigKi | _sigKi `seq` (True) ->
                                                                        (case (tyKiGamNameSingleton nm_ (TyKiGamInfo _sigKi)) of
                                                                         { _lhsOgathTyKiSigGam | _lhsOgathTyKiSigGam `seq` (True) ->
                                                                         (case ((let sem_Decl_KiSig_3 :: T_Decl_3
                                                                                     sem_Decl_KiSig_3 =
                                                                                         (\ _lhsIlexLev
                                                                                            _lhsIpredSameScopeCounter ->
                                                                                              _lhsIlexLev `seq`
                                                                                              (_lhsIpredSameScopeCounter `seq`
                                                                                               ((case (_lhsIpredSameScopeCounter) of
                                                                                                 { _lhsOpredSameScopeCounter | _lhsOpredSameScopeCounter `seq` (True) ->
                                                                                                 (case ((let sem_Decl_KiSig_4 :: T_Decl_4
                                                                                                             sem_Decl_KiSig_4 =
                                                                                                                 (\ _lhsIpatTyGam
                                                                                                                    _lhsItyKiSigGam ->
                                                                                                                      _lhsIpatTyGam `seq`
                                                                                                                      (_lhsItyKiSigGam `seq`
                                                                                                                       ((case (_lhsIpatTyGam) of
                                                                                                                         { _lhsOpatTyGam | _lhsOpatTyGam `seq` (True) ->
                                                                                                                         (case ((let sem_Decl_KiSig_5 :: T_Decl_5
                                                                                                                                     sem_Decl_KiSig_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_Decl_KiSig_6 :: T_Decl_6
                                                                                                                                                               sem_Decl_KiSig_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_Decl_KiSig_7 :: T_Decl_7
                                                                                                                                                                                         sem_Decl_KiSig_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_Decl_KiSig_8 :: T_Decl_8
                                                                                                                                                                                                                          sem_Decl_KiSig_8 =
                                                                                                                                                                                                                              (\ _lhsIpatClGam1 ->
                                                                                                                                                                                                                                   _lhsIpatClGam1 `seq`
                                                                                                                                                                                                                                   ((case (_lhsIpatClGam1) of
                                                                                                                                                                                                                                     { _lhsOpatClGam1 | _lhsOpatClGam1 `seq` (True) ->
                                                                                                                                                                                                                                     (case ((let sem_Decl_KiSig_9 :: T_Decl_9
                                                                                                                                                                                                                                                 sem_Decl_KiSig_9 =
                                                                                                                                                                                                                                                     (\ _lhsIfinKiVarMp
                                                                                                                                                                                                                                                        _lhsIfinTyKiGam
                                                                                                                                                                                                                                                        _lhsIpatClGam2
                                                                                                                                                                                                                                                        _lhsItyTyTySigFreeTvarS ->
                                                                                                                                                                                                                                                          _lhsIfinKiVarMp `seq`
                                                                                                                                                                                                                                                          (_lhsIfinTyKiGam `seq`
                                                                                                                                                                                                                                                           (_lhsIpatClGam2 `seq`
                                                                                                                                                                                                                                                            (_lhsItyTyTySigFreeTvarS `seq`
                                                                                                                                                                                                                                                             ((case (_lhsIpatClGam2) of
                                                                                                                                                                                                                                                               { _lhsOpatClGam2 | _lhsOpatClGam2 `seq` (True) ->
                                                                                                                                                                                                                                                               (case ((let sem_Decl_KiSig_10 :: T_Decl_10
                                                                                                                                                                                                                                                                           sem_Decl_KiSig_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_Decl_KiSig_11 :: T_Decl_11
                                                                                                                                                                                                                                                                                                      sem_Decl_KiSig_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_Decl_KiSig_12 :: T_Decl_12
                                                                                                                                                                                                                                                                                                                               sem_Decl_KiSig_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_Decl_KiSig_13 :: T_Decl_13
                                                                                                                                                                                                                                                                                                                                                           sem_Decl_KiSig_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_Decl_KiSig_14 :: T_Decl_14
                                                                                                                                                                                                                                                                                                                                                                                            sem_Decl_KiSig_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 (_lhsIvalTyGlobFreeTvarS) of
                                                                                                                                                                                                                                                                                                                                                                                                                 { _kiExprOvalTyGlobFreeTvarS | _kiExprOvalTyGlobFreeTvarS `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                 (case (_lhsItyTyTySigFreeTvarS) of
                                                                                                                                                                                                                                                                                                                                                                                                                  { _kiExprOtyTyTySigFreeTvarS | _kiExprOtyTyTySigFreeTvarS `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                  (case (_lhsItyTyGlobFreeTvarS) of
                                                                                                                                                                                                                                                                                                                                                                                                                   { _kiExprOtyTyGlobFreeTvarS | _kiExprOtyTyGlobFreeTvarS `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                   (case (_lhsItyKiGlobFreeTvarS) of
                                                                                                                                                                                                                                                                                                                                                                                                                    { _kiExprOtyKiGlobFreeTvarS | _kiExprOtyKiGlobFreeTvarS `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                    (case (_lhsItr) of
                                                                                                                                                                                                                                                                                                                                                                                                                     { _kiExprOtr | _kiExprOtr `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                     (case (_lhsIsysfEnv) of
                                                                                                                                                                                                                                                                                                                                                                                                                      { _kiExprOsysfEnv | _kiExprOsysfEnv `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                      (case (_lhsIopts) of
                                                                                                                                                                                                                                                                                                                                                                                                                       { _kiExprOopts | _kiExprOopts `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                       (case (_lhsImoduleNm) of
                                                                                                                                                                                                                                                                                                                                                                                                                        { _kiExprOmoduleNm | _kiExprOmoduleNm `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                        (case (_lhsIfinTyVarMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                         { _kiExprOfinTyVarMp | _kiExprOfinTyVarMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                         (case (_lhsIfinTyKiGam) of
                                                                                                                                                                                                                                                                                                                                                                                                                          { _kiExprOfinTyKiGam | _kiExprOfinTyKiGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                          (case (_lhsIfinKiVarMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                           { _kiExprOfinKiVarMp | _kiExprOfinKiVarMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                           (case (kiExpr_3 _kiExprOfinKiVarMp _kiExprOfinTyKiGam _kiExprOfinTyVarMp _kiExprOmoduleNm _kiExprOopts _kiExprOsysfEnv _kiExprOtr _kiExprOtyKiGlobFreeTvarS _kiExprOtyTyGlobFreeTvarS _kiExprOtyTyTySigFreeTvarS _kiExprOvalTyGlobFreeTvarS) of
                                                                                                                                                                                                                                                                                                                                                                                                                            { ( _kiExprIallErrSq,_kiExprIappArgPPL,_kiExprIappFunNm,_kiExprIappFunPP,_kiExprIerrSq,_kiExprIgathMentrelFilterMp,_kiExprIpp,_kiExprIppAST,_kiExprItrpp) | True ->
                                                                                                                                                                                                                                                                                                                                                                                                                                (case (_kiExprIallErrSq) of
                                                                                                                                                                                                                                                                                                                                                                                                                                 { _lhsOallErrSq | _lhsOallErrSq `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                 (case ([]) of
                                                                                                                                                                                                                                                                                                                                                                                                                                  { _lhsObangEvalL | _lhsObangEvalL `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                  (case (_lhsIcSubst) of
                                                                                                                                                                                                                                                                                                                                                                                                                                   { _lhsOcSubst | _lhsOcSubst `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                   (case (_kiExprIerrSq) 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 (_kiExprIgathMentrelFilterMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                         { _lhsOgathMentrelFilterMp | _lhsOgathMentrelFilterMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                         (case (emptyVarMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                          { _lhsOgathTvKiVarMp | _lhsOgathTvKiVarMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                          (case (Set.empty) of
                                                                                                                                                                                                                                                                                                                                                                                                                                           { _lhsOorphanS | _lhsOorphanS `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                           (case (nm_ >#< "::" >#< _kiExprIpp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                            { _pp | _pp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                            (case (_pp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                             { _lhsOpp | _lhsOpp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                             (case (_kiExprIppAST) of
                                                                                                                                                                                                                                                                                                                                                                                                                                              { _lhsOppAST | _lhsOppAST `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                              (case (_kiExprItrpp) 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_Decl_KiSig_14)) of
                                                                                                                                                                                                                                                                                                                                                                                 { ( sem_Decl_14) | True ->
                                                                                                                                                                                                                                                                                                                                                                                 ( _lhsOgathCnstrMp,_lhsOgathRangeMp,_lhsOintlTyKiGam,_lhsOnoLetQuantTyVarIdS,_lhsOscopeGam,_lhsOtyVarMp,sem_Decl_14) }) }) }) }) }) }) }))))))))
                                                                                                                                                                                                                                                                                                                                                       in  sem_Decl_KiSig_13)) of
                                                                                                                                                                                                                                                                                                                                                { ( sem_Decl_13) | True ->
                                                                                                                                                                                                                                                                                                                                                ( _lhsOpatTyVarMp,_lhsOpatValGam,sem_Decl_13) }) }) })))))))
                                                                                                                                                                                                                                                                                                                           in  sem_Decl_KiSig_12)) of
                                                                                                                                                                                                                                                                                                                    { ( sem_Decl_12) | True ->
                                                                                                                                                                                                                                                                                                                    ( _lhsOchrClassDeclSq,_lhsOchrInstDeclSq,_lhsOgathClDfGam,sem_Decl_12) }) }) }) })))
                                                                                                                                                                                                                                                                                                  in  sem_Decl_KiSig_11)) of
                                                                                                                                                                                                                                                                                           { ( sem_Decl_11) | True ->
                                                                                                                                                                                                                                                                                           ( _lhsOgathDataGam,_lhsOgathDeclDataGam,_lhsOgathTySigGam,_lhsOgathTySigVarMp,sem_Decl_11) }) }) }) }) }))))
                                                                                                                                                                                                                                                                       in  sem_Decl_KiSig_10)) of
                                                                                                                                                                                                                                                                { ( sem_Decl_10) | True ->
                                                                                                                                                                                                                                                                ( _lhsOpatClGam2,sem_Decl_10) }) }))))))
                                                                                                                                                                                                                                             in  sem_Decl_KiSig_9)) of
                                                                                                                                                                                                                                      { ( sem_Decl_9) | True ->
                                                                                                                                                                                                                                      ( _lhsOpatClGam1,sem_Decl_9) }) })))
                                                                                                                                                                                                                      in  sem_Decl_KiSig_8)) of
                                                                                                                                                                                                               { ( sem_Decl_8) | True ->
                                                                                                                                                                                                               ( _lhsOgenerDataInfoL,_lhsOgenerDataInfoMp,_lhsOkiVarMp,_lhsOpolVarMp,sem_Decl_8) }) }) }) }) }))))))))))
                                                                                                                                                                                     in  sem_Decl_KiSig_7)) of
                                                                                                                                                                              { ( sem_Decl_7) | True ->
                                                                                                                                                                              ( _lhsOpatKiVarMp,_lhsOpatPolGam,sem_Decl_7) }) }) })))))
                                                                                                                                                           in  sem_Decl_KiSig_6)) of
                                                                                                                                                    { ( sem_Decl_6) | True ->
                                                                                                                                                    ( _lhsOpatTyKiGam,_lhsOtyTyVarMp,sem_Decl_6) }) }) })))))
                                                                                                                                 in  sem_Decl_KiSig_5)) of
                                                                                                                          { ( sem_Decl_5) | True ->
                                                                                                                          ( _lhsOpatTyGam,sem_Decl_5) }) }))))
                                                                                                         in  sem_Decl_KiSig_4)) of
                                                                                                  { ( sem_Decl_4) | True ->
                                                                                                  ( _lhsOpredSameScopeCounter,sem_Decl_4) }) }))))
                                                                                 in  sem_Decl_KiSig_3)) of
                                                                          { ( sem_Decl_3) | True ->
                                                                          ( _lhsOgathTyKiSigGam,sem_Decl_3) }) }) }) }) })))
                                                   in  sem_Decl_KiSig_2)) of
                                            { ( sem_Decl_2) | True ->
                                            ( _lhsOgUniq,_lhsOgathKiSigGam,_lhsOhasInstDecl,sem_Decl_2) }) }) }) }) }) }))))
                   in  sem_Decl_KiSig_1)) of
            { ( sem_Decl_1) | True ->
            ( _lhsOrange,sem_Decl_1) }) }) }) })

sem_Decl_FFI :: Range ->
                FFIWay ->
                String ->
                ForeignEnt ->
                HsName ->
                T_TyExpr ->
                T_Decl

sem_Decl_FFI hsrange_ callconv_ safety_ impEnt_ nm_ tyExpr_ | hsrange_ `seq` (callconv_ `seq` (safety_ `seq` (impEnt_ `seq` (nm_ `seq` (tyExpr_ `seq` (True)))))) =
    (case (tyExpr_) of
     { ( _tyExprIrange,tyExpr_1) | True ->
         (case (rangeUnions [hsrange_, _tyExprIrange , _tyExprIrange]) of
          { _range | _range `seq` (True) ->
          (case (_range) of
           { _lhsOrange | _lhsOrange `seq` (True) ->
           (case ((let sem_Decl_FFI_1 :: T_Decl_1
                       sem_Decl_FFI_1 =
                           (\ _lhsIgUniq
                              _lhsIgathKiSigGam ->
                                _lhsIgUniq `seq`
                                (_lhsIgathKiSigGam `seq`
                                 ((case (let __cont = _lhsIgUniq in seq __cont ( case nextUnique __cont of { (__cont, lUniq) -> case nextUnique __cont of { (__cont, lUniq2) -> case nextUnique __cont of { (__cont, lUniq3) -> case nextUnique __cont of { (__cont, lUniqFFI) -> (__cont,lUniq,lUniq2,lUniq3,lUniqFFI)}}}} )) of
                                   { __tup30 | __tup30 `seq` (True) ->
                                   (case (__tup30) of
                                    { (_tyExprOgUniq,_,_,_,_) | _tyExprOgUniq `seq` (True) ->
                                    (case (tyExpr_1 _tyExprOgUniq) of
                                     { ( _tyExprIgUniq,tyExpr_2) | True ->
                                         (case (_tyExprIgUniq) of
                                          { _lhsOgUniq | _lhsOgUniq `seq` (True) ->
                                          (case (_lhsIgathKiSigGam) of
                                           { _lhsOgathKiSigGam | _lhsOgathKiSigGam `seq` (True) ->
                                           (case (False) of
                                            { _lhsOhasInstDecl | _lhsOhasInstDecl `seq` (True) ->
                                            (case ((let sem_Decl_FFI_2 :: T_Decl_2
                                                        sem_Decl_FFI_2 =
                                                            (\ _lhsIkiGam ->
                                                                 _lhsIkiGam `seq`
                                                                 ((case (emptyGam) of
                                                                   { _lhsOgathTyKiSigGam | _lhsOgathTyKiSigGam `seq` (True) ->
                                                                   (case ((let sem_Decl_FFI_3 :: T_Decl_3
                                                                               sem_Decl_FFI_3 =
                                                                                   (\ _lhsIlexLev
                                                                                      _lhsIpredSameScopeCounter ->
                                                                                        _lhsIlexLev `seq`
                                                                                        (_lhsIpredSameScopeCounter `seq`
                                                                                         ((case (_lhsIpredSameScopeCounter) of
                                                                                           { _lhsOpredSameScopeCounter | _lhsOpredSameScopeCounter `seq` (True) ->
                                                                                           (case ((let sem_Decl_FFI_4 :: T_Decl_4
                                                                                                       sem_Decl_FFI_4 =
                                                                                                           (\ _lhsIpatTyGam
                                                                                                              _lhsItyKiSigGam ->
                                                                                                                _lhsIpatTyGam `seq`
                                                                                                                (_lhsItyKiSigGam `seq`
                                                                                                                 ((case (_lhsIpatTyGam) of
                                                                                                                   { _lhsOpatTyGam | _lhsOpatTyGam `seq` (True) ->
                                                                                                                   (case ((let sem_Decl_FFI_5 :: T_Decl_5
                                                                                                                               sem_Decl_FFI_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_Decl_FFI_6 :: T_Decl_6
                                                                                                                                                         sem_Decl_FFI_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_Decl_FFI_7 :: T_Decl_7
                                                                                                                                                                                   sem_Decl_FFI_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 (_lhsItyKiGam) of
                                                                                                                                                                                                       { _tyExprOtyKiGam | _tyExprOtyKiGam `seq` (True) ->
                                                                                                                                                                                                       (case (_lhsItyGam) of
                                                                                                                                                                                                        { _tyExprOtyGam | _tyExprOtyGam `seq` (True) ->
                                                                                                                                                                                                        (case (_lhsIpolVarMp) of
                                                                                                                                                                                                         { _tyExprOpolVarMp | _tyExprOpolVarMp `seq` (True) ->
                                                                                                                                                                                                         (case (_lhsIpolGam) of
                                                                                                                                                                                                          { _tyExprOpolGam | _tyExprOpolGam `seq` (True) ->
                                                                                                                                                                                                          (case (_lhsIkiVarMp) of
                                                                                                                                                                                                           { _tyExprOkiVarMp | _tyExprOkiVarMp `seq` (True) ->
                                                                                                                                                                                                           (case (polCovariant) of
                                                                                                                                                                                                            { _tyExprOknPolCtx | _tyExprOknPolCtx `seq` (True) ->
                                                                                                                                                                                                            (case (tyExpr_2 _tyExprOtyGam) of
                                                                                                                                                                                                             { ( _tyExprIty,_tyExprItyGam,tyExpr_3) | True ->
                                                                                                                                                                                                                 (case (tyExpr_3 _tyExprOknPolCtx) of
                                                                                                                                                                                                                  { ( _tyExprIpolVarL,tyExpr_4) | True ->
                                                                                                                                                                                                                      (case (tyExpr_4 _tyExprOpolGam _tyExprOpolVarMp) of
                                                                                                                                                                                                                       { ( _tyExprImbStrictness,_tyExprIpolVarMp,tyExpr_5) | True ->
                                                                                                                                                                                                                           (case (tyExpr_5 _tyExprOtyKiGam) of
                                                                                                                                                                                                                            { ( _tyExprIintlTyKiGam,_tyExprItyKiGam,tyExpr_6) | True ->
                                                                                                                                                                                                                                (case (tyExpr_6 _tyExprOkiVarMp) of
                                                                                                                                                                                                                                 { ( _tyExprIgathTyVarPolGam,_tyExprIki,_tyExprIkiVarMp,_tyExprIpol,_tyExprItyVarWildMp,tyExpr_7) | True ->
                                                                                                                                                                                                                                     (case (_tyExprIkiVarMp) of
                                                                                                                                                                                                                                      { _lhsOkiVarMp | _lhsOkiVarMp `seq` (True) ->
                                                                                                                                                                                                                                      (case (_tyExprIpolVarMp) of
                                                                                                                                                                                                                                       { _lhsOpolVarMp | _lhsOpolVarMp `seq` (True) ->
                                                                                                                                                                                                                                       (case ((let sem_Decl_FFI_8 :: T_Decl_8
                                                                                                                                                                                                                                                   sem_Decl_FFI_8 =
                                                                                                                                                                                                                                                       (\ _lhsIpatClGam1 ->
                                                                                                                                                                                                                                                            _lhsIpatClGam1 `seq`
                                                                                                                                                                                                                                                            ((case (_lhsIpatClGam1) of
                                                                                                                                                                                                                                                              { _lhsOpatClGam1 | _lhsOpatClGam1 `seq` (True) ->
                                                                                                                                                                                                                                                              (case ((let sem_Decl_FFI_9 :: T_Decl_9
                                                                                                                                                                                                                                                                          sem_Decl_FFI_9 =
                                                                                                                                                                                                                                                                              (\ _lhsIfinKiVarMp
                                                                                                                                                                                                                                                                                 _lhsIfinTyKiGam
                                                                                                                                                                                                                                                                                 _lhsIpatClGam2
                                                                                                                                                                                                                                                                                 _lhsItyTyTySigFreeTvarS ->
                                                                                                                                                                                                                                                                                   _lhsIfinKiVarMp `seq`
                                                                                                                                                                                                                                                                                   (_lhsIfinTyKiGam `seq`
                                                                                                                                                                                                                                                                                    (_lhsIpatClGam2 `seq`
                                                                                                                                                                                                                                                                                     (_lhsItyTyTySigFreeTvarS `seq`
                                                                                                                                                                                                                                                                                      ((case (_lhsIpatClGam2) of
                                                                                                                                                                                                                                                                                        { _lhsOpatClGam2 | _lhsOpatClGam2 `seq` (True) ->
                                                                                                                                                                                                                                                                                        (case ((let sem_Decl_FFI_10 :: T_Decl_10
                                                                                                                                                                                                                                                                                                    sem_Decl_FFI_10 =
                                                                                                                                                                                                                                                                                                        (\ _lhsIclGam
                                                                                                                                                                                                                                                                                                           _lhsIgathDataGam ->
                                                                                                                                                                                                                                                                                                             _lhsIclGam `seq`
                                                                                                                                                                                                                                                                                                             (_lhsIgathDataGam `seq`
                                                                                                                                                                                                                                                                                                              ((case (_lhsIgathDataGam) of
                                                                                                                                                                                                                                                                                                                { _lhsOgathDataGam | _lhsOgathDataGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                (case (emptyGam) of
                                                                                                                                                                                                                                                                                                                 { _lhsOgathDeclDataGam | _lhsOgathDeclDataGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                 (case (let t   = varmpIncMetaLev _lhsIfinKiVarMp `varUpd` _tyExprIty
                                                                                                                                                                                                                                                                                                                            t2k = tvarKi _lhsIfinTyKiGam _tyExprIintlTyKiGam _lhsIfinKiVarMp emptyVarMp
                                                                                                                                                                                                                                                                                                                        in  tyQuantifyOuter t2k (const False) t) of
                                                                                                                                                                                                                                                                                                                  { _ty_sig_ | _ty_sig_ `seq` (True) ->
                                                                                                                                                                                                                                                                                                                  (case (nm_ `gamSingleton` ValGamInfo _ty_sig_) of
                                                                                                                                                                                                                                                                                                                   { _lhsOgathTySigGam | _lhsOgathTySigGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                   (case (emptyVarMp) of
                                                                                                                                                                                                                                                                                                                    { _lhsOgathTySigVarMp | _lhsOgathTySigVarMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                    (case ((let sem_Decl_FFI_11 :: T_Decl_11
                                                                                                                                                                                                                                                                                                                                sem_Decl_FFI_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_Decl_FFI_12 :: T_Decl_12
                                                                                                                                                                                                                                                                                                                                                         sem_Decl_FFI_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_Decl_FFI_13 :: T_Decl_13
                                                                                                                                                                                                                                                                                                                                                                                     sem_Decl_FFI_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 (_tyExprIintlTyKiGam) 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_Decl_FFI_14 :: T_Decl_14
                                                                                                                                                                                                                                                                                                                                                                                                                      sem_Decl_FFI_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 (_lhsIclGam) of
                                                                                                                                                                                                                                                                                                                                                                                                                                           { _tyExprOclGam | _tyExprOclGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                           (case (tyExpr_7 _tyExprOclGam) of
                                                                                                                                                                                                                                                                                                                                                                                                                                            { ( _tyExprIevTy,tyExpr_8) | True ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                (case (_lhsIvalTyGlobFreeTvarS) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                 { _tyExprOvalTyGlobFreeTvarS | _tyExprOvalTyGlobFreeTvarS `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                 (case (_lhsItyTyTySigFreeTvarS) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                  { _tyExprOtyTyTySigFreeTvarS | _tyExprOtyTyTySigFreeTvarS `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                  (case (_lhsItyTyGlobFreeTvarS) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                   { _tyExprOtyTyGlobFreeTvarS | _tyExprOtyTyGlobFreeTvarS `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                   (case (_lhsItyKiGlobFreeTvarS) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                    { _tyExprOtyKiGlobFreeTvarS | _tyExprOtyKiGlobFreeTvarS `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                    (case (_lhsItr) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                     { _tyExprOtr | _tyExprOtr `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                     (case (_lhsIsysfEnv) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                      { _tyExprOsysfEnv | _tyExprOsysfEnv `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                      (case (_lhsIopts) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                       { _tyExprOopts | _tyExprOopts `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                       (case (_lhsImoduleNm) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                        { _tyExprOmoduleNm | _tyExprOmoduleNm `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                        (case (_lhsIkiGam) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                         { _tyExprOkiGam | _tyExprOkiGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                         (case (_lhsIfinTyVarMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                          { _tyExprOfinTyVarMp | _tyExprOfinTyVarMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                          (case (_lhsIfinTyKiGam) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                           { _tyExprOfinTyKiGam | _tyExprOfinTyKiGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                           (case (_lhsIfinKiVarMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                            { _tyExprOfinKiVarMp | _tyExprOfinKiVarMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                            (case (tyExpr_8 _tyExprOfinKiVarMp _tyExprOfinTyKiGam _tyExprOfinTyVarMp _tyExprOkiGam _tyExprOmoduleNm _tyExprOopts _tyExprOsysfEnv _tyExprOtr _tyExprOtyKiGlobFreeTvarS _tyExprOtyTyGlobFreeTvarS _tyExprOtyTyTySigFreeTvarS _tyExprOvalTyGlobFreeTvarS) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                             { ( _tyExprIallErrSq,_tyExprIappArgPPL,_tyExprIappFunNm,_tyExprIappFunPP,_tyExprIclMissNmS,_tyExprIclNmS,_tyExprIerrSq,_tyExprIgathMentrelFilterMp,_tyExprIpp,_tyExprIppAST,_tyExprItrpp,_tyExprItyWildL) | True ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                 (case (_tyExprIallErrSq) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  { _lhsOallErrSq | _lhsOallErrSq `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (case ([]) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                   { _lhsObangEvalL | _lhsObangEvalL `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                   (case (_lhsIcSubst) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    { _lhsOcSubst | _lhsOcSubst `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (case (__tup30) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                     { (_,_,_,_lUniq3,_) | _lUniq3 `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                     (case (__tup30) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      { (_,_,_lUniq2,_,_) | _lUniq2 `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      (case (__tup30) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                       { (_,_lUniq,_,_,_) | _lUniq `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                       (case (foreignEntExtract impEnt_) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        { _foreignEntInfo | _foreignEntInfo `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (case (let v      = mkTyVar _lUniq
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   funptr = appCon1App (ehcOptBuiltin _lhsIopts ehbnFunPtr)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   io     = appCon1App (ehcOptBuiltin _lhsIopts ehbnIO)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                               in  case targetIsJavaScript (ehcOptTarget _lhsIopts) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     True  -> let v1            = mkTyVar _lUniq2
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  wrappedFunptr = appTopApp [v1, funptr v]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              in case _foreignEntInfo of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   ForeignExtraction_Wrapper -> Ty_Any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   ForeignExtraction_Dynamic -> Ty_Any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   _                         -> Ty_Any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     False -> case _foreignEntInfo of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               ForeignExtraction_Wrapper -> v `app1Arr` io (funptr v)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               ForeignExtraction_Dynamic -> funptr v `app1Arr` v
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               _                         -> Ty_Any) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                         { _knTy | _knTy `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                         (case (defaultFIEnv
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    { feTyGam = _lhsItyGam
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    , feEHCOpts = _lhsIopts
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    , feDataGam = _lhsIdataGam
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    , fePolGam = _lhsIpolGam
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    , feRange = _range
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          { _fe | _fe `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          (case (fitsIn strongFIOpts _fe _lUniq3 (emptyVarMp :: VarMp) _ty_sig_ _knTy) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                           { _foFFI | _foFFI `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                           (case ("foreign import" >#< callconv_ >#< safety_ >#< pp (show impEnt_) >#< nm_ >#< "::" >#< _tyExprIpp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            { _pp | _pp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (case (rngLift _range mkNestErr' _pp [foErrSq _foFFI]) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                             { _lhsOerrSq | _lhsOerrSq `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                             (case ([]) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              { _lhsOffeCBindL | _lhsOffeCBindL `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              (case (__tup30) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                               { (_,_,_,_,_lUniqFFI) | _lUniqFFI `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                               (case ((emptyRCEEnv _lhsIopts) { rceValGam = _lhsIvalGam, rceDataGam = _lhsIdataGam, rceTyVarMp = _lhsIfinTyVarMp }) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                { _rceEnv | _rceEnv `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (case (tyCanonicFFI' True (emptyTyBetaRedEnv' _fe) _ty_sig_) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 { _finalTyExpanded | _finalTyExpanded `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 (case ((appDbg "{Expr,PatExpr,Decl,DataFieldExpr}.sysfty not implemented" :: SysfTy)) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  { _sysfty | _sysfty `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (case (mkCTy _lhsIopts _finalTyExpanded _sysfty) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   { _acorety | _acorety `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   (case (let ffi = ffiCoreMk _lhsIopts (\ty -> CExpr_FFI callconv_ safety_ impEnt_ ty) _lUniqFFI _rceEnv _foreignEntInfo _finalTyExpanded
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          in  [acoreBind1CatTy CBindCateg_Plain nm_ _acorety ffi]) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    { _lhsOffiCBindL | _lhsOffiCBindL `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (case (Seq.empty) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     { _lhsOgathHiddenExports | _lhsOgathHiddenExports `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     (case (Map.empty) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      { _lhsOgathLamMp | _lhsOgathLamMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      (case (_tyExprIgathMentrelFilterMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       { _lhsOgathMentrelFilterMp | _lhsOgathMentrelFilterMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       (case (emptyVarMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        { _lhsOgathTvKiVarMp | _lhsOgathTvKiVarMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (case (Set.empty) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         { _lhsOorphanS | _lhsOorphanS `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         (case (_pp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          { _lhsOpp | _lhsOpp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          (case (trppEmpty) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           { _trppHere | _trppHere `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           (case (ppNestTrPP _lhsIopts ["Decl","FFI"] [pp (show impEnt_),ppTrNm nm_] [_tyExprIppAST] _trppHere) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            { _ppAST | _ppAST `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (case (_ppAST) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             { _lhsOppAST | _lhsOppAST `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             (case (_tyExprItrpp) 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_Decl_FFI_14)) of
                                                                                                                                                                                                                                                                                                                                                                                                           { ( sem_Decl_14) | True ->
                                                                                                                                                                                                                                                                                                                                                                                                           ( _lhsOgathCnstrMp,_lhsOgathRangeMp,_lhsOintlTyKiGam,_lhsOnoLetQuantTyVarIdS,_lhsOscopeGam,_lhsOtyVarMp,sem_Decl_14) }) }) }) }) }) }) }))))))))
                                                                                                                                                                                                                                                                                                                                                                                 in  sem_Decl_FFI_13)) of
                                                                                                                                                                                                                                                                                                                                                                          { ( sem_Decl_13) | True ->
                                                                                                                                                                                                                                                                                                                                                                          ( _lhsOpatTyVarMp,_lhsOpatValGam,sem_Decl_13) }) }) })))))))
                                                                                                                                                                                                                                                                                                                                                     in  sem_Decl_FFI_12)) of
                                                                                                                                                                                                                                                                                                                                              { ( sem_Decl_12) | True ->
                                                                                                                                                                                                                                                                                                                                              ( _lhsOchrClassDeclSq,_lhsOchrInstDeclSq,_lhsOgathClDfGam,sem_Decl_12) }) }) }) })))
                                                                                                                                                                                                                                                                                                                            in  sem_Decl_FFI_11)) of
                                                                                                                                                                                                                                                                                                                     { ( sem_Decl_11) | True ->
                                                                                                                                                                                                                                                                                                                     ( _lhsOgathDataGam,_lhsOgathDeclDataGam,_lhsOgathTySigGam,_lhsOgathTySigVarMp,sem_Decl_11) }) }) }) }) }) }))))
                                                                                                                                                                                                                                                                                                in  sem_Decl_FFI_10)) of
                                                                                                                                                                                                                                                                                         { ( sem_Decl_10) | True ->
                                                                                                                                                                                                                                                                                         ( _lhsOpatClGam2,sem_Decl_10) }) }))))))
                                                                                                                                                                                                                                                                      in  sem_Decl_FFI_9)) of
                                                                                                                                                                                                                                                               { ( sem_Decl_9) | True ->
                                                                                                                                                                                                                                                               ( _lhsOpatClGam1,sem_Decl_9) }) })))
                                                                                                                                                                                                                                               in  sem_Decl_FFI_8)) of
                                                                                                                                                                                                                                        { ( sem_Decl_8) | True ->
                                                                                                                                                                                                                                        ( _lhsOgenerDataInfoL,_lhsOgenerDataInfoMp,_lhsOkiVarMp,_lhsOpolVarMp,sem_Decl_8) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }))))))))))
                                                                                                                                                                               in  sem_Decl_FFI_7)) of
                                                                                                                                                                        { ( sem_Decl_7) | True ->
                                                                                                                                                                        ( _lhsOpatKiVarMp,_lhsOpatPolGam,sem_Decl_7) }) }) })))))
                                                                                                                                                     in  sem_Decl_FFI_6)) of
                                                                                                                                              { ( sem_Decl_6) | True ->
                                                                                                                                              ( _lhsOpatTyKiGam,_lhsOtyTyVarMp,sem_Decl_6) }) }) })))))
                                                                                                                           in  sem_Decl_FFI_5)) of
                                                                                                                    { ( sem_Decl_5) | True ->
                                                                                                                    ( _lhsOpatTyGam,sem_Decl_5) }) }))))
                                                                                                   in  sem_Decl_FFI_4)) of
                                                                                            { ( sem_Decl_4) | True ->
                                                                                            ( _lhsOpredSameScopeCounter,sem_Decl_4) }) }))))
                                                                           in  sem_Decl_FFI_3)) of
                                                                    { ( sem_Decl_3) | True ->
                                                                    ( _lhsOgathTyKiSigGam,sem_Decl_3) }) })))
                                                    in  sem_Decl_FFI_2)) of
                                             { ( sem_Decl_2) | True ->
                                             ( _lhsOgUniq,_lhsOgathKiSigGam,_lhsOhasInstDecl,sem_Decl_2) }) }) }) }) }) }) }))))
                   in  sem_Decl_FFI_1)) of
            { ( sem_Decl_1) | True ->
            ( _lhsOrange,sem_Decl_1) }) }) }) })

sem_Decl_Type :: Range ->
                 HsName ->
                 T_TyExpr ->
                 T_Decl

sem_Decl_Type hsrange_ tyNm_ tyExpr_ | hsrange_ `seq` (tyNm_ `seq` (tyExpr_ `seq` (True))) =
    (case (tyExpr_) of
     { ( _tyExprIrange,tyExpr_1) | True ->
         (case (rangeUnions [hsrange_, _tyExprIrange , _tyExprIrange]) of
          { _range | _range `seq` (True) ->
          (case (_range) of
           { _lhsOrange | _lhsOrange `seq` (True) ->
           (case ((let sem_Decl_Type_1 :: T_Decl_1
                       sem_Decl_Type_1 =
                           (\ _lhsIgUniq
                              _lhsIgathKiSigGam ->
                                _lhsIgUniq `seq`
                                (_lhsIgathKiSigGam `seq`
                                 ((case (let __cont = _lhsIgUniq in seq __cont ( case nextUnique __cont of { (__cont, lUniq) -> case nextUnique __cont of { (__cont, lUniq2) -> case nextUnique __cont of { (__cont, lUniq_17_fitsIn_pol) -> case nextUnique __cont of { (__cont, lUniq_17_seed_pol) -> (__cont,lUniq,lUniq2,lUniq_17_fitsIn_pol,lUniq_17_seed_pol)}}}} )) of
                                   { __tup33 | __tup33 `seq` (True) ->
                                   (case (__tup33) of
                                    { (_tyExprOgUniq,_,_,_,_) | _tyExprOgUniq `seq` (True) ->
                                    (case (tyExpr_1 _tyExprOgUniq) of
                                     { ( _tyExprIgUniq,tyExpr_2) | True ->
                                         (case (_tyExprIgUniq) of
                                          { _lhsOgUniq | _lhsOgUniq `seq` (True) ->
                                          (case (_lhsIgathKiSigGam) of
                                           { _lhsOgathKiSigGam | _lhsOgathKiSigGam `seq` (True) ->
                                           (case (False) of
                                            { _lhsOhasInstDecl | _lhsOhasInstDecl `seq` (True) ->
                                            (case ((let sem_Decl_Type_2 :: T_Decl_2
                                                        sem_Decl_Type_2 =
                                                            (\ _lhsIkiGam ->
                                                                 _lhsIkiGam `seq`
                                                                 ((case (emptyGam) of
                                                                   { _lhsOgathTyKiSigGam | _lhsOgathTyKiSigGam `seq` (True) ->
                                                                   (case ((let sem_Decl_Type_3 :: T_Decl_3
                                                                               sem_Decl_Type_3 =
                                                                                   (\ _lhsIlexLev
                                                                                      _lhsIpredSameScopeCounter ->
                                                                                        _lhsIlexLev `seq`
                                                                                        (_lhsIpredSameScopeCounter `seq`
                                                                                         ((case (_lhsIpredSameScopeCounter) of
                                                                                           { _lhsOpredSameScopeCounter | _lhsOpredSameScopeCounter `seq` (True) ->
                                                                                           (case ((let sem_Decl_Type_4 :: T_Decl_4
                                                                                                       sem_Decl_Type_4 =
                                                                                                           (\ _lhsIpatTyGam
                                                                                                              _lhsItyKiSigGam ->
                                                                                                                _lhsIpatTyGam `seq`
                                                                                                                (_lhsItyKiSigGam `seq`
                                                                                                                 ((case (__tup33) of
                                                                                                                   { (_,_lUniq,_,_,_) | _lUniq `seq` (True) ->
                                                                                                                   (case (mkTyVar _lUniq) of
                                                                                                                    { _typeVar | _typeVar `seq` (True) ->
                                                                                                                    (case (mkTGI _typeVar) of
                                                                                                                     { _typeTgi | _typeTgi `seq` (True) ->
                                                                                                                     (case (gamAdd tyNm_ _typeTgi _lhsIpatTyGam) of
                                                                                                                      { _lhsOpatTyGam | _lhsOpatTyGam `seq` (True) ->
                                                                                                                      (case ((let sem_Decl_Type_5 :: T_Decl_5
                                                                                                                                  sem_Decl_Type_5 =
                                                                                                                                      (\ _lhsIpatTyKiGam
                                                                                                                                         _lhsItyGam
                                                                                                                                         _lhsItyTyVarMp ->
                                                                                                                                           _lhsIpatTyKiGam `seq`
                                                                                                                                           (_lhsItyGam `seq`
                                                                                                                                            (_lhsItyTyVarMp `seq`
                                                                                                                                             ((case (case tyKiGamLookupByName tyNm_ _lhsItyKiSigGam of
                                                                                                                                                       Nothing -> (Ty_Any,False)
                                                                                                                                                       Just i  -> (tkgiKi i,True)) of
                                                                                                                                               { __tup32 | __tup32 `seq` (True) ->
                                                                                                                                               (case (__tup32) of
                                                                                                                                                { (_sigKi,_) | _sigKi `seq` (True) ->
                                                                                                                                                (case (_sigKi) of
                                                                                                                                                 { _knKi | _knKi `seq` (True) ->
                                                                                                                                                 (case (TyKiGamInfo (tyEnsureNonAny _lUniq _knKi)) of
                                                                                                                                                  { _typeTkgi | _typeTkgi `seq` (True) ->
                                                                                                                                                  (case (tyKiGamNameSingleton tyNm_ _typeTkgi `gamUnion` _lhsIpatTyKiGam) of
                                                                                                                                                   { _lhsOpatTyKiGam | _lhsOpatTyKiGam `seq` (True) ->
                                                                                                                                                   (case (_lhsItyGam) of
                                                                                                                                                    { _tyExprOtyGam | _tyExprOtyGam `seq` (True) ->
                                                                                                                                                    (case (__tup33) of
                                                                                                                                                     { (_,_,_lUniq2,_,_) | _lUniq2 `seq` (True) ->
                                                                                                                                                     (case (tyExpr_2 _tyExprOtyGam) of
                                                                                                                                                      { ( _tyExprIty,_tyExprItyGam,tyExpr_3) | True ->
                                                                                                                                                          (case (fitsIn  weakFIOpts defaultFIEnv _lUniq2 _lhsItyTyVarMp
                                                                                                                                                                         _tyExprIty (tgiTy _typeTgi)) of
                                                                                                                                                           { _foTy_ | _foTy_ `seq` (True) ->
                                                                                                                                                           (case (foVarMp _foTy_ `varUpd` _lhsItyTyVarMp) of
                                                                                                                                                            { _lhsOtyTyVarMp | _lhsOtyTyVarMp `seq` (True) ->
                                                                                                                                                            (case ((let sem_Decl_Type_6 :: T_Decl_6
                                                                                                                                                                        sem_Decl_Type_6 =
                                                                                                                                                                            (\ _lhsIpatKiVarMp
                                                                                                                                                                               _lhsIpatPolGam
                                                                                                                                                                               _lhsItyKiGam ->
                                                                                                                                                                                 _lhsIpatKiVarMp `seq`
                                                                                                                                                                                 (_lhsIpatPolGam `seq`
                                                                                                                                                                                  (_lhsItyKiGam `seq`
                                                                                                                                                                                   ((case (_lhsIpatKiVarMp) of
                                                                                                                                                                                     { _lhsOpatKiVarMp | _lhsOpatKiVarMp `seq` (True) ->
                                                                                                                                                                                     (case (__tup33) of
                                                                                                                                                                                      { (_,_,_,_,_lUniq_17_seed_pol) | _lUniq_17_seed_pol `seq` (True) ->
                                                                                                                                                                                      (case (let [v1,v2] = mkNewUIDL 2 _lUniq_17_seed_pol
                                                                                                                                                                                             in  (mkPolVar v1,mkPolVar v2)) of
                                                                                                                                                                                       { __tup31 | __tup31 `seq` (True) ->
                                                                                                                                                                                       (case (__tup31) of
                                                                                                                                                                                        { (_,_polTypeVar) | _polTypeVar `seq` (True) ->
                                                                                                                                                                                        (case (_polTypeVar) of
                                                                                                                                                                                         { _polSig | _polSig `seq` (True) ->
                                                                                                                                                                                         (case (gamAdd tyNm_ (mkPGI _polSig) _lhsIpatPolGam) of
                                                                                                                                                                                          { _lhsOpatPolGam | _lhsOpatPolGam `seq` (True) ->
                                                                                                                                                                                          (case ((let sem_Decl_Type_7 :: T_Decl_7
                                                                                                                                                                                                      sem_Decl_Type_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 (_lhsItyKiGam) of
                                                                                                                                                                                                                          { _tyExprOtyKiGam | _tyExprOtyKiGam `seq` (True) ->
                                                                                                                                                                                                                          (case (_lhsIpolVarMp) of
                                                                                                                                                                                                                           { _tyExprOpolVarMp | _tyExprOpolVarMp `seq` (True) ->
                                                                                                                                                                                                                           (case (_lhsIpolGam) of
                                                                                                                                                                                                                            { _tyExprOpolGam | _tyExprOpolGam `seq` (True) ->
                                                                                                                                                                                                                            (case (_lhsIkiVarMp) of
                                                                                                                                                                                                                             { _tyExprOkiVarMp | _tyExprOkiVarMp `seq` (True) ->
                                                                                                                                                                                                                             (case (__tup31) of
                                                                                                                                                                                                                              { (_polCtxVar,_) | _polCtxVar `seq` (True) ->
                                                                                                                                                                                                                              (case (_polCtxVar) of
                                                                                                                                                                                                                               { _tyExprOknPolCtx | _tyExprOknPolCtx `seq` (True) ->
                                                                                                                                                                                                                               (case (tyExpr_3 _tyExprOknPolCtx) of
                                                                                                                                                                                                                                { ( _tyExprIpolVarL,tyExpr_4) | True ->
                                                                                                                                                                                                                                    (case (tyExpr_4 _tyExprOpolGam _tyExprOpolVarMp) of
                                                                                                                                                                                                                                     { ( _tyExprImbStrictness,_tyExprIpolVarMp,tyExpr_5) | True ->
                                                                                                                                                                                                                                         (case (tyExpr_5 _tyExprOtyKiGam) of
                                                                                                                                                                                                                                          { ( _tyExprIintlTyKiGam,_tyExprItyKiGam,tyExpr_6) | True ->
                                                                                                                                                                                                                                              (case (tyExpr_6 _tyExprOkiVarMp) of
                                                                                                                                                                                                                                               { ( _tyExprIgathTyVarPolGam,_tyExprIki,_tyExprIkiVarMp,_tyExprIpol,_tyExprItyVarWildMp,tyExpr_7) | True ->
                                                                                                                                                                                                                                                   (case (fitsIn  strongFIOpts defaultFIEnv _lUniq2 _tyExprIkiVarMp
                                                                                                                                                                                                                                                                  _tyExprIki (tkgiKi _typeTkgi)) of
                                                                                                                                                                                                                                                    { _foKi_ | _foKi_ `seq` (True) ->
                                                                                                                                                                                                                                                    (case (foVarMp _foKi_ `varUpd` _tyExprIkiVarMp) of
                                                                                                                                                                                                                                                     { _lhsOkiVarMp | _lhsOkiVarMp `seq` (True) ->
                                                                                                                                                                                                                                                     (case (__tup33) of
                                                                                                                                                                                                                                                      { (_,_,_,_lUniq_17_fitsIn_pol,_) | _lUniq_17_fitsIn_pol `seq` (True) ->
                                                                                                                                                                                                                                                      (case (fitsIn weakFIOpts defaultFIEnv _lUniq_17_fitsIn_pol _tyExprIpolVarMp _tyExprIpol _polSig) of
                                                                                                                                                                                                                                                       { _foPol | _foPol `seq` (True) ->
                                                                                                                                                                                                                                                       (case (foVarMp _foPol `varUpd` _tyExprIpolVarMp) of
                                                                                                                                                                                                                                                        { _lhsOpolVarMp | _lhsOpolVarMp `seq` (True) ->
                                                                                                                                                                                                                                                        (case ((let sem_Decl_Type_8 :: T_Decl_8
                                                                                                                                                                                                                                                                    sem_Decl_Type_8 =
                                                                                                                                                                                                                                                                        (\ _lhsIpatClGam1 ->
                                                                                                                                                                                                                                                                             _lhsIpatClGam1 `seq`
                                                                                                                                                                                                                                                                             ((case (_lhsIpatClGam1) of
                                                                                                                                                                                                                                                                               { _lhsOpatClGam1 | _lhsOpatClGam1 `seq` (True) ->
                                                                                                                                                                                                                                                                               (case ((let sem_Decl_Type_9 :: T_Decl_9
                                                                                                                                                                                                                                                                                           sem_Decl_Type_9 =
                                                                                                                                                                                                                                                                                               (\ _lhsIfinKiVarMp
                                                                                                                                                                                                                                                                                                  _lhsIfinTyKiGam
                                                                                                                                                                                                                                                                                                  _lhsIpatClGam2
                                                                                                                                                                                                                                                                                                  _lhsItyTyTySigFreeTvarS ->
                                                                                                                                                                                                                                                                                                    _lhsIfinKiVarMp `seq`
                                                                                                                                                                                                                                                                                                    (_lhsIfinTyKiGam `seq`
                                                                                                                                                                                                                                                                                                     (_lhsIpatClGam2 `seq`
                                                                                                                                                                                                                                                                                                      (_lhsItyTyTySigFreeTvarS `seq`
                                                                                                                                                                                                                                                                                                       ((case (_lhsIpatClGam2) of
                                                                                                                                                                                                                                                                                                         { _lhsOpatClGam2 | _lhsOpatClGam2 `seq` (True) ->
                                                                                                                                                                                                                                                                                                         (case ((let sem_Decl_Type_10 :: T_Decl_10
                                                                                                                                                                                                                                                                                                                     sem_Decl_Type_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_Decl_Type_11 :: T_Decl_11
                                                                                                                                                                                                                                                                                                                                                sem_Decl_Type_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_Decl_Type_12 :: T_Decl_12
                                                                                                                                                                                                                                                                                                                                                                         sem_Decl_Type_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_Decl_Type_13 :: T_Decl_13
                                                                                                                                                                                                                                                                                                                                                                                                     sem_Decl_Type_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 (_tyExprIintlTyKiGam) 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_Decl_Type_14 :: T_Decl_14
                                                                                                                                                                                                                                                                                                                                                                                                                                      sem_Decl_Type_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 (_lhsIclGam) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                           { _tyExprOclGam | _tyExprOclGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                           (case (tyExpr_7 _tyExprOclGam) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                            { ( _tyExprIevTy,tyExpr_8) | True ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                (case (_lhsIvalTyGlobFreeTvarS) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                 { _tyExprOvalTyGlobFreeTvarS | _tyExprOvalTyGlobFreeTvarS `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                 (case (_lhsItyTyTySigFreeTvarS) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  { _tyExprOtyTyTySigFreeTvarS | _tyExprOtyTyTySigFreeTvarS `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (case (_lhsItyTyGlobFreeTvarS) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                   { _tyExprOtyTyGlobFreeTvarS | _tyExprOtyTyGlobFreeTvarS `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                   (case (_lhsItyKiGlobFreeTvarS) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    { _tyExprOtyKiGlobFreeTvarS | _tyExprOtyKiGlobFreeTvarS `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (case (_lhsItr) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                     { _tyExprOtr | _tyExprOtr `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                     (case (_lhsIsysfEnv) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      { _tyExprOsysfEnv | _tyExprOsysfEnv `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      (case (_lhsIopts) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                       { _tyExprOopts | _tyExprOopts `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                       (case (_lhsImoduleNm) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        { _tyExprOmoduleNm | _tyExprOmoduleNm `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (case (_lhsIkiGam) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                         { _tyExprOkiGam | _tyExprOkiGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                         (case (_lhsIfinTyVarMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          { _tyExprOfinTyVarMp | _tyExprOfinTyVarMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          (case (_lhsIfinTyKiGam) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                           { _tyExprOfinTyKiGam | _tyExprOfinTyKiGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                           (case (_lhsIfinKiVarMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            { _tyExprOfinKiVarMp | _tyExprOfinKiVarMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (case (tyExpr_8 _tyExprOfinKiVarMp _tyExprOfinTyKiGam _tyExprOfinTyVarMp _tyExprOkiGam _tyExprOmoduleNm _tyExprOopts _tyExprOsysfEnv _tyExprOtr _tyExprOtyKiGlobFreeTvarS _tyExprOtyTyGlobFreeTvarS _tyExprOtyTyTySigFreeTvarS _tyExprOvalTyGlobFreeTvarS) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                             { ( _tyExprIallErrSq,_tyExprIappArgPPL,_tyExprIappFunNm,_tyExprIappFunPP,_tyExprIclMissNmS,_tyExprIclNmS,_tyExprIerrSq,_tyExprIgathMentrelFilterMp,_tyExprIpp,_tyExprIppAST,_tyExprItrpp,_tyExprItyWildL) | True ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 (case (_tyExprIallErrSq) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  { _lhsOallErrSq | _lhsOallErrSq `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (case ([]) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   { _lhsObangEvalL | _lhsObangEvalL `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   (case (_lhsIcSubst) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    { _lhsOcSubst | _lhsOcSubst `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (case ("type" >#< tyNm_ >#< "=" >#< _tyExprIpp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     { _pp | _pp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     (case (rngLift _range mkNestErr' _pp [ _tyExprIerrSq, foErrSq _foKi_, foErrSq _foPol]) 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 (_tyExprIgathMentrelFilterMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           { _lhsOgathMentrelFilterMp | _lhsOgathMentrelFilterMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           (case (emptyVarMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            { _lhsOgathTvKiVarMp | _lhsOgathTvKiVarMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (case (Set.empty) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             { _lhsOorphanS | _lhsOorphanS `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             (case (_pp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              { _lhsOpp | _lhsOpp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              (case (_tyExprIppAST) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               { _lhsOppAST | _lhsOppAST `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               (case (_tyExprItrpp) 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_Decl_Type_14)) of
                                                                                                                                                                                                                                                                                                                                                                                                                           { ( sem_Decl_14) | True ->
                                                                                                                                                                                                                                                                                                                                                                                                                           ( _lhsOgathCnstrMp,_lhsOgathRangeMp,_lhsOintlTyKiGam,_lhsOnoLetQuantTyVarIdS,_lhsOscopeGam,_lhsOtyVarMp,sem_Decl_14) }) }) }) }) }) }) }))))))))
                                                                                                                                                                                                                                                                                                                                                                                                 in  sem_Decl_Type_13)) of
                                                                                                                                                                                                                                                                                                                                                                                          { ( sem_Decl_13) | True ->
                                                                                                                                                                                                                                                                                                                                                                                          ( _lhsOpatTyVarMp,_lhsOpatValGam,sem_Decl_13) }) }) })))))))
                                                                                                                                                                                                                                                                                                                                                                     in  sem_Decl_Type_12)) of
                                                                                                                                                                                                                                                                                                                                                              { ( sem_Decl_12) | True ->
                                                                                                                                                                                                                                                                                                                                                              ( _lhsOchrClassDeclSq,_lhsOchrInstDeclSq,_lhsOgathClDfGam,sem_Decl_12) }) }) }) })))
                                                                                                                                                                                                                                                                                                                                            in  sem_Decl_Type_11)) of
                                                                                                                                                                                                                                                                                                                                     { ( sem_Decl_11) | True ->
                                                                                                                                                                                                                                                                                                                                     ( _lhsOgathDataGam,_lhsOgathDeclDataGam,_lhsOgathTySigGam,_lhsOgathTySigVarMp,sem_Decl_11) }) }) }) }) }))))
                                                                                                                                                                                                                                                                                                                 in  sem_Decl_Type_10)) of
                                                                                                                                                                                                                                                                                                          { ( sem_Decl_10) | True ->
                                                                                                                                                                                                                                                                                                          ( _lhsOpatClGam2,sem_Decl_10) }) }))))))
                                                                                                                                                                                                                                                                                       in  sem_Decl_Type_9)) of
                                                                                                                                                                                                                                                                                { ( sem_Decl_9) | True ->
                                                                                                                                                                                                                                                                                ( _lhsOpatClGam1,sem_Decl_9) }) })))
                                                                                                                                                                                                                                                                in  sem_Decl_Type_8)) of
                                                                                                                                                                                                                                                         { ( sem_Decl_8) | True ->
                                                                                                                                                                                                                                                         ( _lhsOgenerDataInfoL,_lhsOgenerDataInfoMp,_lhsOkiVarMp,_lhsOpolVarMp,sem_Decl_8) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }))))))))))
                                                                                                                                                                                                  in  sem_Decl_Type_7)) of
                                                                                                                                                                                           { ( sem_Decl_7) | True ->
                                                                                                                                                                                           ( _lhsOpatKiVarMp,_lhsOpatPolGam,sem_Decl_7) }) }) }) }) }) }) })))))
                                                                                                                                                                    in  sem_Decl_Type_6)) of
                                                                                                                                                             { ( sem_Decl_6) | True ->
                                                                                                                                                             ( _lhsOpatTyKiGam,_lhsOtyTyVarMp,sem_Decl_6) }) }) }) }) }) }) }) }) }) }) })))))
                                                                                                                              in  sem_Decl_Type_5)) of
                                                                                                                       { ( sem_Decl_5) | True ->
                                                                                                                       ( _lhsOpatTyGam,sem_Decl_5) }) }) }) }) }))))
                                                                                                   in  sem_Decl_Type_4)) of
                                                                                            { ( sem_Decl_4) | True ->
                                                                                            ( _lhsOpredSameScopeCounter,sem_Decl_4) }) }))))
                                                                           in  sem_Decl_Type_3)) of
                                                                    { ( sem_Decl_3) | True ->
                                                                    ( _lhsOgathTyKiSigGam,sem_Decl_3) }) })))
                                                    in  sem_Decl_Type_2)) of
                                             { ( sem_Decl_2) | True ->
                                             ( _lhsOgUniq,_lhsOgathKiSigGam,_lhsOhasInstDecl,sem_Decl_2) }) }) }) }) }) }) }))))
                   in  sem_Decl_Type_1)) of
            { ( sem_Decl_1) | True ->
            ( _lhsOrange,sem_Decl_1) }) }) }) })

sem_Decl_FFE :: Range ->
                HsName ->
                FFIWay ->
                ForeignEnt ->
                T_Expr ->
                T_TyExpr ->
                T_Decl

sem_Decl_FFE hsrange_ nm_ callconv_ expEnt_ expr_ tyExpr_ | hsrange_ `seq` (nm_ `seq` (callconv_ `seq` (expEnt_ `seq` (expr_ `seq` (tyExpr_ `seq` (True)))))) =
    (case (tyExpr_) of
     { ( _tyExprIrange,tyExpr_1) | True ->
         (case (expr_) of
          { ( _exprIrange,expr_1) | True ->
              (case (rangeUnions [hsrange_, _exprIrange   , _tyExprIrange]) of
               { _range | _range `seq` (True) ->
               (case (_range) of
                { _lhsOrange | _lhsOrange `seq` (True) ->
                (case ((let sem_Decl_FFE_1 :: T_Decl_1
                            sem_Decl_FFE_1 =
                                (\ _lhsIgUniq
                                   _lhsIgathKiSigGam ->
                                     _lhsIgUniq `seq`
                                     (_lhsIgathKiSigGam `seq`
                                      ((case (let __cont = _lhsIgUniq in seq __cont ( case nextUnique __cont of { (__cont, lUniqFFE) -> (__cont,lUniqFFE)} )) of
                                        { __tup35 | __tup35 `seq` (True) ->
                                        (case (__tup35) of
                                         { (_exprOgUniq,_) | _exprOgUniq `seq` (True) ->
                                         (case (expr_1 _exprOgUniq) of
                                          { ( _exprIgUniq,_exprIhasInstDecl,expr_2) | True ->
                                              (case (_exprIgUniq) of
                                               { _tyExprOgUniq | _tyExprOgUniq `seq` (True) ->
                                               (case (tyExpr_1 _tyExprOgUniq) of
                                                { ( _tyExprIgUniq,tyExpr_2) | True ->
                                                    (case (_tyExprIgUniq) of
                                                     { _lhsOgUniq | _lhsOgUniq `seq` (True) ->
                                                     (case (_lhsIgathKiSigGam) of
                                                      { _lhsOgathKiSigGam | _lhsOgathKiSigGam `seq` (True) ->
                                                      (case (False) of
                                                       { _lhsOhasInstDecl | _lhsOhasInstDecl `seq` (True) ->
                                                       (case ((let sem_Decl_FFE_2 :: T_Decl_2
                                                                   sem_Decl_FFE_2 =
                                                                       (\ _lhsIkiGam ->
                                                                            _lhsIkiGam `seq`
                                                                            ((case (emptyGam) of
                                                                              { _lhsOgathTyKiSigGam | _lhsOgathTyKiSigGam `seq` (True) ->
                                                                              (case ((let sem_Decl_FFE_3 :: T_Decl_3
                                                                                          sem_Decl_FFE_3 =
                                                                                              (\ _lhsIlexLev
                                                                                                 _lhsIpredSameScopeCounter ->
                                                                                                   _lhsIlexLev `seq`
                                                                                                   (_lhsIpredSameScopeCounter `seq`
                                                                                                    ((case (_lhsIpredSameScopeCounter) of
                                                                                                      { _exprOpredSameScopeCounter | _exprOpredSameScopeCounter `seq` (True) ->
                                                                                                      (case (_lhsIlexLev) of
                                                                                                       { _exprOlexLev | _exprOlexLev `seq` (True) ->
                                                                                                       (case (_lhsIkiGam) of
                                                                                                        { _exprOkiGam | _exprOkiGam `seq` (True) ->
                                                                                                        (case (True) of
                                                                                                         { _exprOisFirstLet | _exprOisFirstLet `seq` (True) ->
                                                                                                         (case (expr_2 _exprOisFirstLet _exprOkiGam _exprOlexLev _exprOpredSameScopeCounter) of
                                                                                                          { ( _exprIpredSameScopeCounter,expr_3) | True ->
                                                                                                              (case (_exprIpredSameScopeCounter) of
                                                                                                               { _lhsOpredSameScopeCounter | _lhsOpredSameScopeCounter `seq` (True) ->
                                                                                                               (case ((let sem_Decl_FFE_4 :: T_Decl_4
                                                                                                                           sem_Decl_FFE_4 =
                                                                                                                               (\ _lhsIpatTyGam
                                                                                                                                  _lhsItyKiSigGam ->
                                                                                                                                    _lhsIpatTyGam `seq`
                                                                                                                                    (_lhsItyKiSigGam `seq`
                                                                                                                                     ((case (_lhsIpatTyGam) of
                                                                                                                                       { _lhsOpatTyGam | _lhsOpatTyGam `seq` (True) ->
                                                                                                                                       (case ((let sem_Decl_FFE_5 :: T_Decl_5
                                                                                                                                                   sem_Decl_FFE_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_Decl_FFE_6 :: T_Decl_6
                                                                                                                                                                             sem_Decl_FFE_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_Decl_FFE_7 :: T_Decl_7
                                                                                                                                                                                                       sem_Decl_FFE_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 (_lhsItyKiGlobFreeTvarS) of
                                                                                                                                                                                                                          { _exprOtyKiGlobFreeTvarS | _exprOtyKiGlobFreeTvarS `seq` (True) ->
                                                                                                                                                                                                                          (case (_lhsItyKiGam) of
                                                                                                                                                                                                                           { _exprOtyKiGam | _exprOtyKiGam `seq` (True) ->
                                                                                                                                                                                                                           (case (_lhsItyGam) of
                                                                                                                                                                                                                            { _exprOtyGam | _exprOtyGam `seq` (True) ->
                                                                                                                                                                                                                            (case (_lhsIpredScope) of
                                                                                                                                                                                                                             { _exprOpredScope | _exprOpredScope `seq` (True) ->
                                                                                                                                                                                                                             (case (_lhsIpolVarMp) of
                                                                                                                                                                                                                              { _exprOpolVarMp | _exprOpolVarMp `seq` (True) ->
                                                                                                                                                                                                                              (case (_lhsIpolGam) of
                                                                                                                                                                                                                               { _exprOpolGam | _exprOpolGam `seq` (True) ->
                                                                                                                                                                                                                               (case (_lhsIopts) of
                                                                                                                                                                                                                                { _exprOopts | _exprOopts `seq` (True) ->
                                                                                                                                                                                                                                (case (_lhsIkiVarMp) of
                                                                                                                                                                                                                                 { _exprOkiVarMp | _exprOkiVarMp `seq` (True) ->
                                                                                                                                                                                                                                 (case (_lhsIgenerDataInfoMp) of
                                                                                                                                                                                                                                  { _exprOgenerDataInfoMp | _exprOgenerDataInfoMp `seq` (True) ->
                                                                                                                                                                                                                                  (case (expr_3 _exprOgenerDataInfoMp _exprOkiVarMp _exprOopts _exprOpolGam _exprOpolVarMp _exprOpredScope _exprOtyGam _exprOtyKiGam _exprOtyKiGlobFreeTvarS) of
                                                                                                                                                                                                                                   { ( _exprIgenerDataInfoMp,_exprIkiVarMp,_exprIpolVarMp,expr_4) | True ->
                                                                                                                                                                                                                                       (case (_exprIgenerDataInfoMp) of
                                                                                                                                                                                                                                        { _lhsOgenerDataInfoMp | _lhsOgenerDataInfoMp `seq` (True) ->
                                                                                                                                                                                                                                        (case (_lhsItyKiGam) of
                                                                                                                                                                                                                                         { _tyExprOtyKiGam | _tyExprOtyKiGam `seq` (True) ->
                                                                                                                                                                                                                                         (case (_lhsItyGam) of
                                                                                                                                                                                                                                          { _tyExprOtyGam | _tyExprOtyGam `seq` (True) ->
                                                                                                                                                                                                                                          (case (_exprIpolVarMp) of
                                                                                                                                                                                                                                           { _tyExprOpolVarMp | _tyExprOpolVarMp `seq` (True) ->
                                                                                                                                                                                                                                           (case (_lhsIpolGam) of
                                                                                                                                                                                                                                            { _tyExprOpolGam | _tyExprOpolGam `seq` (True) ->
                                                                                                                                                                                                                                            (case (_exprIkiVarMp) of
                                                                                                                                                                                                                                             { _tyExprOkiVarMp | _tyExprOkiVarMp `seq` (True) ->
                                                                                                                                                                                                                                             (case (polCovariant) of
                                                                                                                                                                                                                                              { _tyExprOknPolCtx | _tyExprOknPolCtx `seq` (True) ->
                                                                                                                                                                                                                                              (case (tyExpr_2 _tyExprOtyGam) of
                                                                                                                                                                                                                                               { ( _tyExprIty,_tyExprItyGam,tyExpr_3) | True ->
                                                                                                                                                                                                                                                   (case (tyExpr_3 _tyExprOknPolCtx) of
                                                                                                                                                                                                                                                    { ( _tyExprIpolVarL,tyExpr_4) | True ->
                                                                                                                                                                                                                                                        (case (tyExpr_4 _tyExprOpolGam _tyExprOpolVarMp) of
                                                                                                                                                                                                                                                         { ( _tyExprImbStrictness,_tyExprIpolVarMp,tyExpr_5) | True ->
                                                                                                                                                                                                                                                             (case (tyExpr_5 _tyExprOtyKiGam) of
                                                                                                                                                                                                                                                              { ( _tyExprIintlTyKiGam,_tyExprItyKiGam,tyExpr_6) | True ->
                                                                                                                                                                                                                                                                  (case (tyExpr_6 _tyExprOkiVarMp) of
                                                                                                                                                                                                                                                                   { ( _tyExprIgathTyVarPolGam,_tyExprIki,_tyExprIkiVarMp,_tyExprIpol,_tyExprItyVarWildMp,tyExpr_7) | True ->
                                                                                                                                                                                                                                                                       (case (_tyExprIkiVarMp) of
                                                                                                                                                                                                                                                                        { _lhsOkiVarMp | _lhsOkiVarMp `seq` (True) ->
                                                                                                                                                                                                                                                                        (case (_tyExprIpolVarMp) of
                                                                                                                                                                                                                                                                         { _lhsOpolVarMp | _lhsOpolVarMp `seq` (True) ->
                                                                                                                                                                                                                                                                         (case ((let sem_Decl_FFE_8 :: T_Decl_8
                                                                                                                                                                                                                                                                                     sem_Decl_FFE_8 =
                                                                                                                                                                                                                                                                                         (\ _lhsIpatClGam1 ->
                                                                                                                                                                                                                                                                                              _lhsIpatClGam1 `seq`
                                                                                                                                                                                                                                                                                              ((case (_lhsIpatClGam1) of
                                                                                                                                                                                                                                                                                                { _lhsOpatClGam1 | _lhsOpatClGam1 `seq` (True) ->
                                                                                                                                                                                                                                                                                                (case ((let sem_Decl_FFE_9 :: T_Decl_9
                                                                                                                                                                                                                                                                                                            sem_Decl_FFE_9 =
                                                                                                                                                                                                                                                                                                                (\ _lhsIfinKiVarMp
                                                                                                                                                                                                                                                                                                                   _lhsIfinTyKiGam
                                                                                                                                                                                                                                                                                                                   _lhsIpatClGam2
                                                                                                                                                                                                                                                                                                                   _lhsItyTyTySigFreeTvarS ->
                                                                                                                                                                                                                                                                                                                     _lhsIfinKiVarMp `seq`
                                                                                                                                                                                                                                                                                                                     (_lhsIfinTyKiGam `seq`
                                                                                                                                                                                                                                                                                                                      (_lhsIpatClGam2 `seq`
                                                                                                                                                                                                                                                                                                                       (_lhsItyTyTySigFreeTvarS `seq`
                                                                                                                                                                                                                                                                                                                        ((case (_lhsIpatClGam2) of
                                                                                                                                                                                                                                                                                                                          { _lhsOpatClGam2 | _lhsOpatClGam2 `seq` (True) ->
                                                                                                                                                                                                                                                                                                                          (case ((let sem_Decl_FFE_10 :: T_Decl_10
                                                                                                                                                                                                                                                                                                                                      sem_Decl_FFE_10 =
                                                                                                                                                                                                                                                                                                                                          (\ _lhsIclGam
                                                                                                                                                                                                                                                                                                                                             _lhsIgathDataGam ->
                                                                                                                                                                                                                                                                                                                                               _lhsIclGam `seq`
                                                                                                                                                                                                                                                                                                                                               (_lhsIgathDataGam `seq`
                                                                                                                                                                                                                                                                                                                                                ((case (_lhsItyTyTySigFreeTvarS) of
                                                                                                                                                                                                                                                                                                                                                  { _exprOtyTyTySigFreeTvarS | _exprOtyTyTySigFreeTvarS `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                  (case (_lhsIgathDataGam) of
                                                                                                                                                                                                                                                                                                                                                   { _exprOgathDataGam | _exprOgathDataGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                   (case (_lhsIfinTyKiGam) of
                                                                                                                                                                                                                                                                                                                                                    { _exprOfinTyKiGam | _exprOfinTyKiGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                    (case (_lhsIfinKiVarMp) of
                                                                                                                                                                                                                                                                                                                                                     { _exprOfinKiVarMp | _exprOfinKiVarMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                     (case (_lhsIclGam) of
                                                                                                                                                                                                                                                                                                                                                      { _exprOclGam | _exprOclGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                      (case (expr_4 _exprOclGam _exprOfinKiVarMp _exprOfinTyKiGam _exprOgathDataGam _exprOtyTyTySigFreeTvarS) of
                                                                                                                                                                                                                                                                                                                                                       { ( _exprIgathDataGam,expr_5) | True ->
                                                                                                                                                                                                                                                                                                                                                           (case (_exprIgathDataGam) of
                                                                                                                                                                                                                                                                                                                                                            { _lhsOgathDataGam | _lhsOgathDataGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                            (case (emptyGam) of
                                                                                                                                                                                                                                                                                                                                                             { _lhsOgathDeclDataGam | _lhsOgathDeclDataGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                             (case (let t   = varmpIncMetaLev _lhsIfinKiVarMp `varUpd` _tyExprIty
                                                                                                                                                                                                                                                                                                                                                                        t2k = tvarKi _lhsIfinTyKiGam _tyExprIintlTyKiGam _lhsIfinKiVarMp emptyVarMp
                                                                                                                                                                                                                                                                                                                                                                    in  tyQuantifyOuter t2k (const False) t) of
                                                                                                                                                                                                                                                                                                                                                              { _ty_sig_ | _ty_sig_ `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                              (case (nm_ `gamSingleton` ValGamInfo _ty_sig_) of
                                                                                                                                                                                                                                                                                                                                                               { _lhsOgathTySigGam | _lhsOgathTySigGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                               (case (emptyVarMp) of
                                                                                                                                                                                                                                                                                                                                                                { _lhsOgathTySigVarMp | _lhsOgathTySigVarMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                (case ((let sem_Decl_FFE_11 :: T_Decl_11
                                                                                                                                                                                                                                                                                                                                                                            sem_Decl_FFE_11 =
                                                                                                                                                                                                                                                                                                                                                                                (\ _lhsIdataGam ->
                                                                                                                                                                                                                                                                                                                                                                                     _lhsIdataGam `seq`
                                                                                                                                                                                                                                                                                                                                                                                     ((case (_lhsIdataGam) of
                                                                                                                                                                                                                                                                                                                                                                                       { _exprOdataGam | _exprOdataGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                       (case (expr_5 _exprOdataGam) of
                                                                                                                                                                                                                                                                                                                                                                                        { ( _exprIchrClassDeclSq,_exprIchrFIIn,_exprIchrInstDeclSq,_exprIgathClDfGam,expr_6) | True ->
                                                                                                                                                                                                                                                                                                                                                                                            (case (_exprIchrClassDeclSq) of
                                                                                                                                                                                                                                                                                                                                                                                             { _lhsOchrClassDeclSq | _lhsOchrClassDeclSq `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                             (case (_exprIchrInstDeclSq) of
                                                                                                                                                                                                                                                                                                                                                                                              { _lhsOchrInstDeclSq | _lhsOchrInstDeclSq `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                              (case (_exprIgathClDfGam) of
                                                                                                                                                                                                                                                                                                                                                                                               { _lhsOgathClDfGam | _lhsOgathClDfGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                               (case ((let sem_Decl_FFE_12 :: T_Decl_12
                                                                                                                                                                                                                                                                                                                                                                                                           sem_Decl_FFE_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_Decl_FFE_13 :: T_Decl_13
                                                                                                                                                                                                                                                                                                                                                                                                                                       sem_Decl_FFE_13 =
                                                                                                                                                                                                                                                                                                                                                                                                                                           (\ _lhsIchrStore
                                                                                                                                                                                                                                                                                                                                                                                                                                              _lhsIclDfGam
                                                                                                                                                                                                                                                                                                                                                                                                                                              _lhsItyTyGlobFreeTvarS
                                                                                                                                                                                                                                                                                                                                                                                                                                              _lhsItyVarMp
                                                                                                                                                                                                                                                                                                                                                                                                                                              _lhsIvalGam
                                                                                                                                                                                                                                                                                                                                                                                                                                              _lhsIvalTyGlobFreeTvarS ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                _lhsIchrStore `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                                                (_lhsIclDfGam `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                                                 (_lhsItyTyGlobFreeTvarS `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                                                  (_lhsItyVarMp `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                                                   (_lhsIvalGam `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                                                    (_lhsIvalTyGlobFreeTvarS `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                                                     ((case (_lhsIvalTyGlobFreeTvarS) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                       { _exprOvalTyGlobFreeTvarS | _exprOvalTyGlobFreeTvarS `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                       (case (_lhsIvalGam) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                        { _exprOvalGam | _exprOvalGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                        (case (_lhsItyVarMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                         { _exprOtyVarMp | _exprOtyVarMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                         (case (_lhsItyTyGlobFreeTvarS) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                          { _exprOtyTyGlobFreeTvarS | _exprOtyTyGlobFreeTvarS `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                          (case (_lhsItvKiVarMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                           { _exprOtvKiVarMp | _exprOtvKiVarMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                           (case (_ty_sig_) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                            { _knTy | _knTy `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                            (case (_knTy) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                             { _exprOknTy | _exprOknTy `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                             (case (_lhsIclDfGam) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                              { _exprOclDfGam | _exprOclDfGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                              (case (_lhsIchrStore) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                               { _exprOchrStore | _exprOchrStore `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                               (case (strongFIOpts) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                { _exprFiOpts | _exprFiOpts `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                (case (_exprFiOpts) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                 { _exprOfiOpts | _exprOfiOpts `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                 (case (expr_6 _exprOchrStore _exprOclDfGam _exprOfiOpts _exprOknTy _exprOtvKiVarMp _exprOtyTyGlobFreeTvarS _exprOtyVarMp _exprOvalGam _exprOvalTyGlobFreeTvarS) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  { ( _exprIgathCnstrMp,_exprIgathRangeMp,_exprIgathValGam,_exprInoLetQuantTyVarIdS,_exprIty,_exprItyVarMp,expr_7) | True ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      (case (_exprIgathCnstrMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                       { _lhsOgathCnstrMp | _lhsOgathCnstrMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                       (case (_exprIgathRangeMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        { _lhsOgathRangeMp | _lhsOgathRangeMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (case (_tyExprIintlTyKiGam) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                         { _lhsOintlTyKiGam | _lhsOintlTyKiGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                         (case (_exprInoLetQuantTyVarIdS) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          { _lhsOnoLetQuantTyVarIdS | _lhsOnoLetQuantTyVarIdS `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          (case (emptyGam) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                           { _lhsOscopeGam | _lhsOscopeGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                           (case (_exprItyVarMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            { _lhsOtyVarMp | _lhsOtyVarMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (case ((let sem_Decl_FFE_14 :: T_Decl_14
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        sem_Decl_FFE_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
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             { _exprOsysfEnv | _exprOsysfEnv `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             (case (_lhsIrangeMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              { _exprOrangeMp | _exprOrangeMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              (case (_lhsIfinValGam) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               { _exprOfinValGam | _exprOfinValGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               (case (_lhsIfinTyVarMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                { _exprOfinTyVarMp | _exprOfinTyVarMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (case (_lhsIclGam) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 { _tyExprOclGam | _tyExprOclGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 (case (tyExpr_7 _tyExprOclGam) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  { ( _tyExprIevTy,tyExpr_8) | True ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      (case (_lhsIvalTyGlobFreeTvarS) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       { _tyExprOvalTyGlobFreeTvarS | _tyExprOvalTyGlobFreeTvarS `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       (case (_lhsItyTyTySigFreeTvarS) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        { _tyExprOtyTyTySigFreeTvarS | _tyExprOtyTyTySigFreeTvarS `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (case (_lhsItyTyGlobFreeTvarS) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         { _tyExprOtyTyGlobFreeTvarS | _tyExprOtyTyGlobFreeTvarS `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         (case (_lhsItyKiGlobFreeTvarS) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          { _tyExprOtyKiGlobFreeTvarS | _tyExprOtyKiGlobFreeTvarS `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          (case (_lhsItr) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           { _tyExprOtr | _tyExprOtr `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           (case (_lhsIsysfEnv) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            { _tyExprOsysfEnv | _tyExprOsysfEnv `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (case (_lhsIopts) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             { _tyExprOopts | _tyExprOopts `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             (case (_lhsImoduleNm) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              { _tyExprOmoduleNm | _tyExprOmoduleNm `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              (case (_lhsIkiGam) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               { _tyExprOkiGam | _tyExprOkiGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               (case (_lhsIfinTyVarMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                { _tyExprOfinTyVarMp | _tyExprOfinTyVarMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (case (_lhsIfinTyKiGam) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 { _tyExprOfinTyKiGam | _tyExprOfinTyKiGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 (case (_lhsIfinKiVarMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  { _tyExprOfinKiVarMp | _tyExprOfinKiVarMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (case (tyExpr_8 _tyExprOfinKiVarMp _tyExprOfinTyKiGam _tyExprOfinTyVarMp _tyExprOkiGam _tyExprOmoduleNm _tyExprOopts _tyExprOsysfEnv _tyExprOtr _tyExprOtyKiGlobFreeTvarS _tyExprOtyTyGlobFreeTvarS _tyExprOtyTyTySigFreeTvarS _tyExprOvalTyGlobFreeTvarS) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   { ( _tyExprIallErrSq,_tyExprIappArgPPL,_tyExprIappFunNm,_tyExprIappFunPP,_tyExprIclMissNmS,_tyExprIclNmS,_tyExprIerrSq,_tyExprIgathMentrelFilterMp,_tyExprIpp,_tyExprIppAST,_tyExprItrpp,_tyExprItyWildL) | True ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       (case (_lhsItr) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        { _exprOtr | _exprOtr `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (case (_lhsImoduleNm) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         { _exprOmoduleNm | _exprOmoduleNm `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         (case (_lhsIchrScopeBindMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          { _exprOchrScopeBindMp | _exprOchrScopeBindMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          (case (_lhsIchrEvidBindMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           { _exprOchrEvidBindMp | _exprOchrEvidBindMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           (case (_lhsIcSubst) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            { _exprOcSubst | _exprOcSubst `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (case (ExprCtxt_Top) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             { _exprOexprCtxt | _exprOexprCtxt `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             (case (expr_7 _exprOcSubst _exprOchrEvidBindMp _exprOchrScopeBindMp _exprOexprCtxt _exprOfinTyVarMp _exprOfinValGam _exprOmoduleNm _exprOrangeMp _exprOsysfEnv _exprOtr) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              { ( _exprIallErrSq,_exprIappArgCoeL,_exprIappArgPPL,_exprIappFunCExpr,_exprIappFunNm,_exprIappFunPP,_exprIbackCBindL,_exprIcSubst,_exprIcaseFailS,_exprIcexpr,_exprIerrSq,_exprIfrontCBindL,_exprIfuCExprL,_exprIgathClGam,_exprIgathHiddenExports,_exprIgathKiGam,_exprIgathLamMp,_exprIgathMentrelFilterMp,_exprIgathPolGam,_exprIgathTvKiVarMp,_exprIgathTyGam,_exprIgathTyKiGam,_exprIisNewtype,_exprIlamArgPPL,_exprIlamBodyPP,_exprIletCBody,_exprIletTyCBindL,_exprIletValCBindL,_exprIletValMainCBindL,_exprIorphanS,_exprIpp,_exprIppAST,_exprItrpp) | True ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (case (_exprIallErrSq `Seq.union` _tyExprIallErrSq) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   { _lhsOallErrSq | _lhsOallErrSq `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   (case ([]) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    { _lhsObangEvalL | _lhsObangEvalL `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (case (_exprIcSubst) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     { _lhsOcSubst | _lhsOcSubst `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     (case (_exprIerrSq `Seq.union` _tyExprIerrSq) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      { _lhsOerrSq | _lhsOerrSq `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      (case (__tup35) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       { (_,_lUniqFFE) | _lUniqFFE `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       (case ((emptyRCEEnv _lhsIopts) { rceValGam = _lhsIvalGam, rceDataGam = _lhsIdataGam, rceTyVarMp = _lhsIfinTyVarMp }) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        { _rceEnv | _rceEnv `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (case (defaultFIEnv
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   { feTyGam = _lhsItyGam
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   , feEHCOpts = _lhsIopts
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   , feDataGam = _lhsIdataGam
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   , fePolGam = _lhsIpolGam
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   , feRange = _range
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   }) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         { _fe | _fe `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         (case (tyCanonicFFI' True (emptyTyBetaRedEnv' _fe) _ty_sig_) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          { _finalTyExpanded | _finalTyExpanded `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          (case (ffeCoreMk _lhsIopts _lUniqFFE _rceEnv _finalTyExpanded) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           { __tup34 | __tup34 `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           (case (__tup34) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            { (_ffeMkCExpr,_) | _ffeMkCExpr `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (case (_ffeMkCExpr _exprIcexpr) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             { _ffeCExpr | _ffeCExpr `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             (case (__tup34) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              { (_,_ffeTy) | _ffeTy `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              (case ([acoreBind1Asp1 nm_ (CBound_FFE callconv_ expEnt_ _ffeCExpr _ffeTy)]) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               { _lhsOffeCBindL | _lhsOffeCBindL `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               (case ([]) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                { _lhsOffiCBindL | _lhsOffiCBindL `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (case (_exprIgathHiddenExports) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 { _lhsOgathHiddenExports | _lhsOgathHiddenExports `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 (case (_exprIgathLamMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  { _lhsOgathLamMp | _lhsOgathLamMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (case (mentrelFilterMpSingleton [_lhsImoduleNm] IdOcc_Val nm_
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         `mentrelFilterMpUnion`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         _tyExprIgathMentrelFilterMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   { _gathMentrelFilterMp | _gathMentrelFilterMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   (case (_gathMentrelFilterMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    { _lhsOgathMentrelFilterMp | _lhsOgathMentrelFilterMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (case (_exprIgathTvKiVarMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     { _lhsOgathTvKiVarMp | _lhsOgathTvKiVarMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     (case (_exprIorphanS) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      { _lhsOorphanS | _lhsOorphanS `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      (case ("foreign export" >#< nm_ >#< callconv_ >#< ppForeignEnt expEnt_ >#< _exprIpp >#< "::" >#< _tyExprIpp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       { _pp | _pp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       (case (_pp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        { _lhsOpp | _lhsOpp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (case (trppEmpty) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         { _trppHere | _trppHere `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         (case (ppNestTrPP _lhsIopts ["Decl","FFE"] [ppTrNm nm_,pp expEnt_] [_exprIppAST,_tyExprIppAST] _trppHere) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          { _ppAST | _ppAST `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          (case (_ppAST) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           { _lhsOppAST | _lhsOppAST `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           (case (_exprItrpp >< _tyExprItrpp) 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_Decl_FFE_14)) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                             { ( sem_Decl_14) | True ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                             ( _lhsOgathCnstrMp,_lhsOgathRangeMp,_lhsOintlTyKiGam,_lhsOnoLetQuantTyVarIdS,_lhsOscopeGam,_lhsOtyVarMp,sem_Decl_14) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }))))))))
                                                                                                                                                                                                                                                                                                                                                                                                                                   in  sem_Decl_FFE_13)) of
                                                                                                                                                                                                                                                                                                                                                                                                                            { ( sem_Decl_13) | True ->
                                                                                                                                                                                                                                                                                                                                                                                                                            ( _lhsOpatTyVarMp,_lhsOpatValGam,sem_Decl_13) }) }) })))))))
                                                                                                                                                                                                                                                                                                                                                                                                       in  sem_Decl_FFE_12)) of
                                                                                                                                                                                                                                                                                                                                                                                                { ( sem_Decl_12) | True ->
                                                                                                                                                                                                                                                                                                                                                                                                ( _lhsOchrClassDeclSq,_lhsOchrInstDeclSq,_lhsOgathClDfGam,sem_Decl_12) }) }) }) }) }) })))
                                                                                                                                                                                                                                                                                                                                                                        in  sem_Decl_FFE_11)) of
                                                                                                                                                                                                                                                                                                                                                                 { ( sem_Decl_11) | True ->
                                                                                                                                                                                                                                                                                                                                                                 ( _lhsOgathDataGam,_lhsOgathDeclDataGam,_lhsOgathTySigGam,_lhsOgathTySigVarMp,sem_Decl_11) }) }) }) }) }) }) }) }) }) }) }) }))))
                                                                                                                                                                                                                                                                                                                                  in  sem_Decl_FFE_10)) of
                                                                                                                                                                                                                                                                                                                           { ( sem_Decl_10) | True ->
                                                                                                                                                                                                                                                                                                                           ( _lhsOpatClGam2,sem_Decl_10) }) }))))))
                                                                                                                                                                                                                                                                                                        in  sem_Decl_FFE_9)) of
                                                                                                                                                                                                                                                                                                 { ( sem_Decl_9) | True ->
                                                                                                                                                                                                                                                                                                 ( _lhsOpatClGam1,sem_Decl_9) }) })))
                                                                                                                                                                                                                                                                                 in  sem_Decl_FFE_8)) of
                                                                                                                                                                                                                                                                          { ( sem_Decl_8) | True ->
                                                                                                                                                                                                                                                                          ( _lhsOgenerDataInfoL,_lhsOgenerDataInfoMp,_lhsOkiVarMp,_lhsOpolVarMp,sem_Decl_8) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }))))))))))
                                                                                                                                                                                                   in  sem_Decl_FFE_7)) of
                                                                                                                                                                                            { ( sem_Decl_7) | True ->
                                                                                                                                                                                            ( _lhsOpatKiVarMp,_lhsOpatPolGam,sem_Decl_7) }) }) })))))
                                                                                                                                                                         in  sem_Decl_FFE_6)) of
                                                                                                                                                                  { ( sem_Decl_6) | True ->
                                                                                                                                                                  ( _lhsOpatTyKiGam,_lhsOtyTyVarMp,sem_Decl_6) }) }) })))))
                                                                                                                                               in  sem_Decl_FFE_5)) of
                                                                                                                                        { ( sem_Decl_5) | True ->
                                                                                                                                        ( _lhsOpatTyGam,sem_Decl_5) }) }))))
                                                                                                                       in  sem_Decl_FFE_4)) of
                                                                                                                { ( sem_Decl_4) | True ->
                                                                                                                ( _lhsOpredSameScopeCounter,sem_Decl_4) }) }) }) }) }) }) }))))
                                                                                      in  sem_Decl_FFE_3)) of
                                                                               { ( sem_Decl_3) | True ->
                                                                               ( _lhsOgathTyKiSigGam,sem_Decl_3) }) })))
                                                               in  sem_Decl_FFE_2)) of
                                                        { ( sem_Decl_2) | True ->
                                                        ( _lhsOgUniq,_lhsOgathKiSigGam,_lhsOhasInstDecl,sem_Decl_2) }) }) }) }) }) }) }) }) }))))
                        in  sem_Decl_FFE_1)) of
                 { ( sem_Decl_1) | True ->
                 ( _lhsOrange,sem_Decl_1) }) }) }) }) })

sem_Decl_GenerRep :: Range ->
                     Int ->
                     Int ->
                     HsName ->
                     ([HsName]) ->
                     ([(HsName,[HsName])]) ->
                     T_Decl

sem_Decl_GenerRep hsrange_ maxArity_ arity_ tyNm_ conNmL_ recFldNmL_ | hsrange_ `seq` (maxArity_ `seq` (arity_ `seq` (tyNm_ `seq` (conNmL_ `seq` (recFldNmL_ `seq` (True)))))) =
    (case (hsrange_) of
     { _range | _range `seq` (True) ->
     (case (_range) of
      { _lhsOrange | _lhsOrange `seq` (True) ->
      (case ((let sem_Decl_GenerRep_1 :: T_Decl_1
                  sem_Decl_GenerRep_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_Decl_GenerRep_2 :: T_Decl_2
                                            sem_Decl_GenerRep_2 =
                                                (\ _lhsIkiGam ->
                                                     _lhsIkiGam `seq`
                                                     ((case (emptyGam) of
                                                       { _lhsOgathTyKiSigGam | _lhsOgathTyKiSigGam `seq` (True) ->
                                                       (case ((let sem_Decl_GenerRep_3 :: T_Decl_3
                                                                   sem_Decl_GenerRep_3 =
                                                                       (\ _lhsIlexLev
                                                                          _lhsIpredSameScopeCounter ->
                                                                            _lhsIlexLev `seq`
                                                                            (_lhsIpredSameScopeCounter `seq`
                                                                             ((case (_lhsIpredSameScopeCounter) of
                                                                               { _lhsOpredSameScopeCounter | _lhsOpredSameScopeCounter `seq` (True) ->
                                                                               (case ((let sem_Decl_GenerRep_4 :: T_Decl_4
                                                                                           sem_Decl_GenerRep_4 =
                                                                                               (\ _lhsIpatTyGam
                                                                                                  _lhsItyKiSigGam ->
                                                                                                    _lhsIpatTyGam `seq`
                                                                                                    (_lhsItyKiSigGam `seq`
                                                                                                     ((case (_lhsIpatTyGam) of
                                                                                                       { _lhsOpatTyGam | _lhsOpatTyGam `seq` (True) ->
                                                                                                       (case ((let sem_Decl_GenerRep_5 :: T_Decl_5
                                                                                                                   sem_Decl_GenerRep_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_Decl_GenerRep_6 :: T_Decl_6
                                                                                                                                             sem_Decl_GenerRep_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_Decl_GenerRep_7 :: T_Decl_7
                                                                                                                                                                       sem_Decl_GenerRep_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 (case Map.lookup tyNm_ _lhsIgenerDataInfoMp of
                                                                                                                                                                                                   Just i  | arity_ == maxArity_                              -> ([i], [])
                                                                                                                                                                                                   Nothing | ehcOptIsUnderDev UnderDev_NameAnalysis _lhsIopts -> ([], [rngLift _range mkErr_NamesNotIntrod "datatype" [tyNm_]])
                                                                                                                                                                                                   _                                                          -> ([], [])) of
                                                                                                                                                                                         { __tup36 | __tup36 `seq` (True) ->
                                                                                                                                                                                         (case (__tup36) of
                                                                                                                                                                                          { (_generDataInfoL,_) | _generDataInfoL `seq` (True) ->
                                                                                                                                                                                          (case (_generDataInfoL) 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_Decl_GenerRep_8 :: T_Decl_8
                                                                                                                                                                                                          sem_Decl_GenerRep_8 =
                                                                                                                                                                                                              (\ _lhsIpatClGam1 ->
                                                                                                                                                                                                                   _lhsIpatClGam1 `seq`
                                                                                                                                                                                                                   ((case (_lhsIpatClGam1) of
                                                                                                                                                                                                                     { _lhsOpatClGam1 | _lhsOpatClGam1 `seq` (True) ->
                                                                                                                                                                                                                     (case ((let sem_Decl_GenerRep_9 :: T_Decl_9
                                                                                                                                                                                                                                 sem_Decl_GenerRep_9 =
                                                                                                                                                                                                                                     (\ _lhsIfinKiVarMp
                                                                                                                                                                                                                                        _lhsIfinTyKiGam
                                                                                                                                                                                                                                        _lhsIpatClGam2
                                                                                                                                                                                                                                        _lhsItyTyTySigFreeTvarS ->
                                                                                                                                                                                                                                          _lhsIfinKiVarMp `seq`
                                                                                                                                                                                                                                          (_lhsIfinTyKiGam `seq`
                                                                                                                                                                                                                                           (_lhsIpatClGam2 `seq`
                                                                                                                                                                                                                                            (_lhsItyTyTySigFreeTvarS `seq`
                                                                                                                                                                                                                                             ((case (_lhsIpatClGam2) of
                                                                                                                                                                                                                                               { _lhsOpatClGam2 | _lhsOpatClGam2 `seq` (True) ->
                                                                                                                                                                                                                                               (case ((let sem_Decl_GenerRep_10 :: T_Decl_10
                                                                                                                                                                                                                                                           sem_Decl_GenerRep_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_Decl_GenerRep_11 :: T_Decl_11
                                                                                                                                                                                                                                                                                      sem_Decl_GenerRep_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_Decl_GenerRep_12 :: T_Decl_12
                                                                                                                                                                                                                                                                                                               sem_Decl_GenerRep_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_Decl_GenerRep_13 :: T_Decl_13
                                                                                                                                                                                                                                                                                                                                           sem_Decl_GenerRep_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_Decl_GenerRep_14 :: T_Decl_14
                                                                                                                                                                                                                                                                                                                                                                            sem_Decl_GenerRep_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 ("generic" >#< (arity_ >|< "<=" >|< maxArity_ >#< tyNm_ >-< (vlist conNmL_) >-< (ppAssocLV $ assocLMapElt ppCurlysCommas recFldNmL_))) of
                                                                                                                                                                                                                                                                                                                                                                                                    { _pp | _pp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                    (case (__tup36) of
                                                                                                                                                                                                                                                                                                                                                                                                     { (_,_errsNoIntroNm) | _errsNoIntroNm `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                     (case (rngLift _range mkNestErr' _pp [Seq.fromList _errsNoIntroNm]) 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 (_pp) of
                                                                                                                                                                                                                                                                                                                                                                                                              { _lhsOpp | _lhsOpp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                              (case (empty) 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_Decl_GenerRep_14)) of
                                                                                                                                                                                                                                                                                                                                                                 { ( sem_Decl_14) | True ->
                                                                                                                                                                                                                                                                                                                                                                 ( _lhsOgathCnstrMp,_lhsOgathRangeMp,_lhsOintlTyKiGam,_lhsOnoLetQuantTyVarIdS,_lhsOscopeGam,_lhsOtyVarMp,sem_Decl_14) }) }) }) }) }) }) }))))))))
                                                                                                                                                                                                                                                                                                                                       in  sem_Decl_GenerRep_13)) of
                                                                                                                                                                                                                                                                                                                                { ( sem_Decl_13) | True ->
                                                                                                                                                                                                                                                                                                                                ( _lhsOpatTyVarMp,_lhsOpatValGam,sem_Decl_13) }) }) })))))))
                                                                                                                                                                                                                                                                                                           in  sem_Decl_GenerRep_12)) of
                                                                                                                                                                                                                                                                                                    { ( sem_Decl_12) | True ->
                                                                                                                                                                                                                                                                                                    ( _lhsOchrClassDeclSq,_lhsOchrInstDeclSq,_lhsOgathClDfGam,sem_Decl_12) }) }) }) })))
                                                                                                                                                                                                                                                                                  in  sem_Decl_GenerRep_11)) of
                                                                                                                                                                                                                                                                           { ( sem_Decl_11) | True ->
                                                                                                                                                                                                                                                                           ( _lhsOgathDataGam,_lhsOgathDeclDataGam,_lhsOgathTySigGam,_lhsOgathTySigVarMp,sem_Decl_11) }) }) }) }) }))))
                                                                                                                                                                                                                                                       in  sem_Decl_GenerRep_10)) of
                                                                                                                                                                                                                                                { ( sem_Decl_10) | True ->
                                                                                                                                                                                                                                                ( _lhsOpatClGam2,sem_Decl_10) }) }))))))
                                                                                                                                                                                                                             in  sem_Decl_GenerRep_9)) of
                                                                                                                                                                                                                      { ( sem_Decl_9) | True ->
                                                                                                                                                                                                                      ( _lhsOpatClGam1,sem_Decl_9) }) })))
                                                                                                                                                                                                      in  sem_Decl_GenerRep_8)) of
                                                                                                                                                                                               { ( sem_Decl_8) | True ->
                                                                                                                                                                                               ( _lhsOgenerDataInfoL,_lhsOgenerDataInfoMp,_lhsOkiVarMp,_lhsOpolVarMp,sem_Decl_8) }) }) }) }) }) }) }))))))))))
                                                                                                                                                                   in  sem_Decl_GenerRep_7)) of
                                                                                                                                                            { ( sem_Decl_7) | True ->
                                                                                                                                                            ( _lhsOpatKiVarMp,_lhsOpatPolGam,sem_Decl_7) }) }) })))))
                                                                                                                                         in  sem_Decl_GenerRep_6)) of
                                                                                                                                  { ( sem_Decl_6) | True ->
                                                                                                                                  ( _lhsOpatTyKiGam,_lhsOtyTyVarMp,sem_Decl_6) }) }) })))))
                                                                                                               in  sem_Decl_GenerRep_5)) of
                                                                                                        { ( sem_Decl_5) | True ->
                                                                                                        ( _lhsOpatTyGam,sem_Decl_5) }) }))))
                                                                                       in  sem_Decl_GenerRep_4)) of
                                                                                { ( sem_Decl_4) | True ->
                                                                                ( _lhsOpredSameScopeCounter,sem_Decl_4) }) }))))
                                                               in  sem_Decl_GenerRep_3)) of
                                                        { ( sem_Decl_3) | True ->
                                                        ( _lhsOgathTyKiSigGam,sem_Decl_3) }) })))
                                        in  sem_Decl_GenerRep_2)) of
                                 { ( sem_Decl_2) | True ->
                                 ( _lhsOgUniq,_lhsOgathKiSigGam,_lhsOhasInstDecl,sem_Decl_2) }) }) }) }))))
              in  sem_Decl_GenerRep_1)) of
       { ( sem_Decl_1) | True ->
       ( _lhsOrange,sem_Decl_1) }) }) })

sem_Decl_FusionDecl :: Range ->
                       HsName ->
                       T_Decl

sem_Decl_FusionDecl hsrange_ fuseNm_ | hsrange_ `seq` (fuseNm_ `seq` (True)) =
    (case (hsrange_) of
     { _range | _range `seq` (True) ->
     (case (_range) of
      { _lhsOrange | _lhsOrange `seq` (True) ->
      (case ((let sem_Decl_FusionDecl_1 :: T_Decl_1
                  sem_Decl_FusionDecl_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_Decl_FusionDecl_2 :: T_Decl_2
                                            sem_Decl_FusionDecl_2 =
                                                (\ _lhsIkiGam ->
                                                     _lhsIkiGam `seq`
                                                     ((case (emptyGam) of
                                                       { _lhsOgathTyKiSigGam | _lhsOgathTyKiSigGam `seq` (True) ->
                                                       (case ((let sem_Decl_FusionDecl_3 :: T_Decl_3
                                                                   sem_Decl_FusionDecl_3 =
                                                                       (\ _lhsIlexLev
                                                                          _lhsIpredSameScopeCounter ->
                                                                            _lhsIlexLev `seq`
                                                                            (_lhsIpredSameScopeCounter `seq`
                                                                             ((case (_lhsIpredSameScopeCounter) of
                                                                               { _lhsOpredSameScopeCounter | _lhsOpredSameScopeCounter `seq` (True) ->
                                                                               (case ((let sem_Decl_FusionDecl_4 :: T_Decl_4
                                                                                           sem_Decl_FusionDecl_4 =
                                                                                               (\ _lhsIpatTyGam
                                                                                                  _lhsItyKiSigGam ->
                                                                                                    _lhsIpatTyGam `seq`
                                                                                                    (_lhsItyKiSigGam `seq`
                                                                                                     ((case (_lhsIpatTyGam) of
                                                                                                       { _lhsOpatTyGam | _lhsOpatTyGam `seq` (True) ->
                                                                                                       (case ((let sem_Decl_FusionDecl_5 :: T_Decl_5
                                                                                                                   sem_Decl_FusionDecl_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_Decl_FusionDecl_6 :: T_Decl_6
                                                                                                                                             sem_Decl_FusionDecl_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_Decl_FusionDecl_7 :: T_Decl_7
                                                                                                                                                                       sem_Decl_FusionDecl_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_Decl_FusionDecl_8 :: T_Decl_8
                                                                                                                                                                                                        sem_Decl_FusionDecl_8 =
                                                                                                                                                                                                            (\ _lhsIpatClGam1 ->
                                                                                                                                                                                                                 _lhsIpatClGam1 `seq`
                                                                                                                                                                                                                 ((case (_lhsIpatClGam1) of
                                                                                                                                                                                                                   { _lhsOpatClGam1 | _lhsOpatClGam1 `seq` (True) ->
                                                                                                                                                                                                                   (case ((let sem_Decl_FusionDecl_9 :: T_Decl_9
                                                                                                                                                                                                                               sem_Decl_FusionDecl_9 =
                                                                                                                                                                                                                                   (\ _lhsIfinKiVarMp
                                                                                                                                                                                                                                      _lhsIfinTyKiGam
                                                                                                                                                                                                                                      _lhsIpatClGam2
                                                                                                                                                                                                                                      _lhsItyTyTySigFreeTvarS ->
                                                                                                                                                                                                                                        _lhsIfinKiVarMp `seq`
                                                                                                                                                                                                                                        (_lhsIfinTyKiGam `seq`
                                                                                                                                                                                                                                         (_lhsIpatClGam2 `seq`
                                                                                                                                                                                                                                          (_lhsItyTyTySigFreeTvarS `seq`
                                                                                                                                                                                                                                           ((case (_lhsIpatClGam2) of
                                                                                                                                                                                                                                             { _lhsOpatClGam2 | _lhsOpatClGam2 `seq` (True) ->
                                                                                                                                                                                                                                             (case ((let sem_Decl_FusionDecl_10 :: T_Decl_10
                                                                                                                                                                                                                                                         sem_Decl_FusionDecl_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_Decl_FusionDecl_11 :: T_Decl_11
                                                                                                                                                                                                                                                                                    sem_Decl_FusionDecl_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_Decl_FusionDecl_12 :: T_Decl_12
                                                                                                                                                                                                                                                                                                             sem_Decl_FusionDecl_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_Decl_FusionDecl_13 :: T_Decl_13
                                                                                                                                                                                                                                                                                                                                         sem_Decl_FusionDecl_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_Decl_FusionDecl_14 :: T_Decl_14
                                                                                                                                                                                                                                                                                                                                                                          sem_Decl_FusionDecl_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.singleton
                                                                                                                                                                                                                                                                                                                                                                                                                fuseNm_
                                                                                                                                                                                                                                                                                                                                                                                                                (emptyLamInfo {laminfoBindAspMp = Map.singleton acbaspkeyFusionRole (LamInfoBindAsp_FusionRole FusionRole_Fuse)})) 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 ("fuse" >#< fuseNm_) of
                                                                                                                                                                                                                                                                                                                                                                                                          { _pp | _pp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                          (case (_pp) of
                                                                                                                                                                                                                                                                                                                                                                                                           { _lhsOpp | _lhsOpp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                           (case (empty) 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_Decl_FusionDecl_14)) of
                                                                                                                                                                                                                                                                                                                                                               { ( sem_Decl_14) | True ->
                                                                                                                                                                                                                                                                                                                                                               ( _lhsOgathCnstrMp,_lhsOgathRangeMp,_lhsOintlTyKiGam,_lhsOnoLetQuantTyVarIdS,_lhsOscopeGam,_lhsOtyVarMp,sem_Decl_14) }) }) }) }) }) }) }))))))))
                                                                                                                                                                                                                                                                                                                                     in  sem_Decl_FusionDecl_13)) of
                                                                                                                                                                                                                                                                                                                              { ( sem_Decl_13) | True ->
                                                                                                                                                                                                                                                                                                                              ( _lhsOpatTyVarMp,_lhsOpatValGam,sem_Decl_13) }) }) })))))))
                                                                                                                                                                                                                                                                                                         in  sem_Decl_FusionDecl_12)) of
                                                                                                                                                                                                                                                                                                  { ( sem_Decl_12) | True ->
                                                                                                                                                                                                                                                                                                  ( _lhsOchrClassDeclSq,_lhsOchrInstDeclSq,_lhsOgathClDfGam,sem_Decl_12) }) }) }) })))
                                                                                                                                                                                                                                                                                in  sem_Decl_FusionDecl_11)) of
                                                                                                                                                                                                                                                                         { ( sem_Decl_11) | True ->
                                                                                                                                                                                                                                                                         ( _lhsOgathDataGam,_lhsOgathDeclDataGam,_lhsOgathTySigGam,_lhsOgathTySigVarMp,sem_Decl_11) }) }) }) }) }))))
                                                                                                                                                                                                                                                     in  sem_Decl_FusionDecl_10)) of
                                                                                                                                                                                                                                              { ( sem_Decl_10) | True ->
                                                                                                                                                                                                                                              ( _lhsOpatClGam2,sem_Decl_10) }) }))))))
                                                                                                                                                                                                                           in  sem_Decl_FusionDecl_9)) of
                                                                                                                                                                                                                    { ( sem_Decl_9) | True ->
                                                                                                                                                                                                                    ( _lhsOpatClGam1,sem_Decl_9) }) })))
                                                                                                                                                                                                    in  sem_Decl_FusionDecl_8)) of
                                                                                                                                                                                             { ( sem_Decl_8) | True ->
                                                                                                                                                                                             ( _lhsOgenerDataInfoL,_lhsOgenerDataInfoMp,_lhsOkiVarMp,_lhsOpolVarMp,sem_Decl_8) }) }) }) }) }))))))))))
                                                                                                                                                                   in  sem_Decl_FusionDecl_7)) of
                                                                                                                                                            { ( sem_Decl_7) | True ->
                                                                                                                                                            ( _lhsOpatKiVarMp,_lhsOpatPolGam,sem_Decl_7) }) }) })))))
                                                                                                                                         in  sem_Decl_FusionDecl_6)) of
                                                                                                                                  { ( sem_Decl_6) | True ->
                                                                                                                                  ( _lhsOpatTyKiGam,_lhsOtyTyVarMp,sem_Decl_6) }) }) })))))
                                                                                                               in  sem_Decl_FusionDecl_5)) of
                                                                                                        { ( sem_Decl_5) | True ->
                                                                                                        ( _lhsOpatTyGam,sem_Decl_5) }) }))))
                                                                                       in  sem_Decl_FusionDecl_4)) of
                                                                                { ( sem_Decl_4) | True ->
                                                                                ( _lhsOpredSameScopeCounter,sem_Decl_4) }) }))))
                                                               in  sem_Decl_FusionDecl_3)) of
                                                        { ( sem_Decl_3) | True ->
                                                        ( _lhsOgathTyKiSigGam,sem_Decl_3) }) })))
                                        in  sem_Decl_FusionDecl_2)) of
                                 { ( sem_Decl_2) | True ->
                                 ( _lhsOgUniq,_lhsOgathKiSigGam,_lhsOhasInstDecl,sem_Decl_2) }) }) }) }))))
              in  sem_Decl_FusionDecl_1)) of
       { ( sem_Decl_1) | True ->
       ( _lhsOrange,sem_Decl_1) }) }) })

sem_Decl_FusionConv :: Range ->
                       HsName ->
                       HsName ->
                       T_Decl

sem_Decl_FusionConv hsrange_ conNm_ absNm_ | hsrange_ `seq` (conNm_ `seq` (absNm_ `seq` (True))) =
    (case (hsrange_) of
     { _range | _range `seq` (True) ->
     (case (_range) of
      { _lhsOrange | _lhsOrange `seq` (True) ->
      (case ((let sem_Decl_FusionConv_1 :: T_Decl_1
                  sem_Decl_FusionConv_1 =
                      (\ _lhsIgUniq
                         _lhsIgathKiSigGam ->
                           _lhsIgUniq `seq`
                           (_lhsIgathKiSigGam `seq`
                            ((case (let __cont = _lhsIgUniq in seq __cont ( case nextUnique __cont of { (__cont, lUniq_buildInverse) -> (__cont,lUniq_buildInverse)} )) of
                              { __tup37 | __tup37 `seq` (True) ->
                              (case (__tup37) of
                               { (_lhsOgUniq,_) | _lhsOgUniq `seq` (True) ->
                               (case (_lhsIgathKiSigGam) of
                                { _lhsOgathKiSigGam | _lhsOgathKiSigGam `seq` (True) ->
                                (case (False) of
                                 { _lhsOhasInstDecl | _lhsOhasInstDecl `seq` (True) ->
                                 (case ((let sem_Decl_FusionConv_2 :: T_Decl_2
                                             sem_Decl_FusionConv_2 =
                                                 (\ _lhsIkiGam ->
                                                      _lhsIkiGam `seq`
                                                      ((case (emptyGam) of
                                                        { _lhsOgathTyKiSigGam | _lhsOgathTyKiSigGam `seq` (True) ->
                                                        (case ((let sem_Decl_FusionConv_3 :: T_Decl_3
                                                                    sem_Decl_FusionConv_3 =
                                                                        (\ _lhsIlexLev
                                                                           _lhsIpredSameScopeCounter ->
                                                                             _lhsIlexLev `seq`
                                                                             (_lhsIpredSameScopeCounter `seq`
                                                                              ((case (_lhsIpredSameScopeCounter) of
                                                                                { _lhsOpredSameScopeCounter | _lhsOpredSameScopeCounter `seq` (True) ->
                                                                                (case ((let sem_Decl_FusionConv_4 :: T_Decl_4
                                                                                            sem_Decl_FusionConv_4 =
                                                                                                (\ _lhsIpatTyGam
                                                                                                   _lhsItyKiSigGam ->
                                                                                                     _lhsIpatTyGam `seq`
                                                                                                     (_lhsItyKiSigGam `seq`
                                                                                                      ((case (_lhsIpatTyGam) of
                                                                                                        { _lhsOpatTyGam | _lhsOpatTyGam `seq` (True) ->
                                                                                                        (case ((let sem_Decl_FusionConv_5 :: T_Decl_5
                                                                                                                    sem_Decl_FusionConv_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_Decl_FusionConv_6 :: T_Decl_6
                                                                                                                                              sem_Decl_FusionConv_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_Decl_FusionConv_7 :: T_Decl_7
                                                                                                                                                                        sem_Decl_FusionConv_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_Decl_FusionConv_8 :: T_Decl_8
                                                                                                                                                                                                         sem_Decl_FusionConv_8 =
                                                                                                                                                                                                             (\ _lhsIpatClGam1 ->
                                                                                                                                                                                                                  _lhsIpatClGam1 `seq`
                                                                                                                                                                                                                  ((case (_lhsIpatClGam1) of
                                                                                                                                                                                                                    { _lhsOpatClGam1 | _lhsOpatClGam1 `seq` (True) ->
                                                                                                                                                                                                                    (case ((let sem_Decl_FusionConv_9 :: T_Decl_9
                                                                                                                                                                                                                                sem_Decl_FusionConv_9 =
                                                                                                                                                                                                                                    (\ _lhsIfinKiVarMp
                                                                                                                                                                                                                                       _lhsIfinTyKiGam
                                                                                                                                                                                                                                       _lhsIpatClGam2
                                                                                                                                                                                                                                       _lhsItyTyTySigFreeTvarS ->
                                                                                                                                                                                                                                         _lhsIfinKiVarMp `seq`
                                                                                                                                                                                                                                         (_lhsIfinTyKiGam `seq`
                                                                                                                                                                                                                                          (_lhsIpatClGam2 `seq`
                                                                                                                                                                                                                                           (_lhsItyTyTySigFreeTvarS `seq`
                                                                                                                                                                                                                                            ((case (_lhsIpatClGam2) of
                                                                                                                                                                                                                                              { _lhsOpatClGam2 | _lhsOpatClGam2 `seq` (True) ->
                                                                                                                                                                                                                                              (case ((let sem_Decl_FusionConv_10 :: T_Decl_10
                                                                                                                                                                                                                                                          sem_Decl_FusionConv_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_Decl_FusionConv_11 :: T_Decl_11
                                                                                                                                                                                                                                                                                     sem_Decl_FusionConv_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_Decl_FusionConv_12 :: T_Decl_12
                                                                                                                                                                                                                                                                                                              sem_Decl_FusionConv_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_Decl_FusionConv_13 :: T_Decl_13
                                                                                                                                                                                                                                                                                                                                          sem_Decl_FusionConv_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_Decl_FusionConv_14 :: T_Decl_14
                                                                                                                                                                                                                                                                                                                                                                           sem_Decl_FusionConv_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 (__tup37) of
                                                                                                                                                                                                                                                                                                                                                                                                   { (_,_lUniq_buildInverse) | _lUniq_buildInverse `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                   (case (maybe (appDbg $ "EH.FinalInfo.Decl.FusionConv.finAbsTy: " ++ show absNm_) vgiTy $ valGamLookup absNm_ _lhsIfinValGam) of
                                                                                                                                                                                                                                                                                                                                                                                                    { _finAbsTy | _finAbsTy `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                    (case (maybe (appDbg $ "EH.FinalInfo.Decl.FusionConv.finConTy: " ++ show conNm_) vgiTy $ valGamLookup conNm_ _lhsIfinValGam) of
                                                                                                                                                                                                                                                                                                                                                                                                     { _finConTy | _finConTy `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                     (case (defaultFIEnv
                                                                                                                                                                                                                                                                                                                                                                                                                { feTyGam = _lhsItyGam
                                                                                                                                                                                                                                                                                                                                                                                                                , feEHCOpts = _lhsIopts
                                                                                                                                                                                                                                                                                                                                                                                                                , feDataGam = _lhsIdataGam
                                                                                                                                                                                                                                                                                                                                                                                                                , fePolGam = _lhsIpolGam
                                                                                                                                                                                                                                                                                                                                                                                                                , feRange = _range
                                                                                                                                                                                                                                                                                                                                                                                                                }) of
                                                                                                                                                                                                                                                                                                                                                                                                      { _fe | _fe `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                      (case (let opts = unifyFIOpts { fiMbMkErrClash = Just $ rngLift _range Err_FusionBuildInverse }
                                                                                                                                                                                                                                                                                                                                                                                                             in  fitsIn opts _fe _lUniq_buildInverse _lhsIfinTyVarMp _finConTy (appArrInverse _finAbsTy)) of
                                                                                                                                                                                                                                                                                                                                                                                                       { _foBuildInverse | _foBuildInverse `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                       (case ("convert" >#< ppCommas [absNm_, conNm_]) of
                                                                                                                                                                                                                                                                                                                                                                                                        { _pp | _pp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                        (case (rngLift _range mkNestErr' _pp [foErrSq _foBuildInverse]) 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.fromList
                                                                                                                                                                                                                                                                                                                                                                                                                       [ ( conNm_, emptyLamInfo {laminfoBindAspMp = Map.singleton acbaspkeyFusionRole (LamInfoBindAsp_FusionRole FusionRole_BuildLeft)} )
                                                                                                                                                                                                                                                                                                                                                                                                                       , ( absNm_, emptyLamInfo {laminfoBindAspMp = Map.singleton acbaspkeyFusionRole (LamInfoBindAsp_FusionRole FusionRole_BuildRight)} )
                                                                                                                                                                                                                                                                                                                                                                                                                       ]) 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 (_pp) of
                                                                                                                                                                                                                                                                                                                                                                                                                 { _lhsOpp | _lhsOpp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                 (case (empty) 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_Decl_FusionConv_14)) of
                                                                                                                                                                                                                                                                                                                                                                { ( sem_Decl_14) | True ->
                                                                                                                                                                                                                                                                                                                                                                ( _lhsOgathCnstrMp,_lhsOgathRangeMp,_lhsOintlTyKiGam,_lhsOnoLetQuantTyVarIdS,_lhsOscopeGam,_lhsOtyVarMp,sem_Decl_14) }) }) }) }) }) }) }))))))))
                                                                                                                                                                                                                                                                                                                                      in  sem_Decl_FusionConv_13)) of
                                                                                                                                                                                                                                                                                                                               { ( sem_Decl_13) | True ->
                                                                                                                                                                                                                                                                                                                               ( _lhsOpatTyVarMp,_lhsOpatValGam,sem_Decl_13) }) }) })))))))
                                                                                                                                                                                                                                                                                                          in  sem_Decl_FusionConv_12)) of
                                                                                                                                                                                                                                                                                                   { ( sem_Decl_12) | True ->
                                                                                                                                                                                                                                                                                                   ( _lhsOchrClassDeclSq,_lhsOchrInstDeclSq,_lhsOgathClDfGam,sem_Decl_12) }) }) }) })))
                                                                                                                                                                                                                                                                                 in  sem_Decl_FusionConv_11)) of
                                                                                                                                                                                                                                                                          { ( sem_Decl_11) | True ->
                                                                                                                                                                                                                                                                          ( _lhsOgathDataGam,_lhsOgathDeclDataGam,_lhsOgathTySigGam,_lhsOgathTySigVarMp,sem_Decl_11) }) }) }) }) }))))
                                                                                                                                                                                                                                                      in  sem_Decl_FusionConv_10)) of
                                                                                                                                                                                                                                               { ( sem_Decl_10) | True ->
                                                                                                                                                                                                                                               ( _lhsOpatClGam2,sem_Decl_10) }) }))))))
                                                                                                                                                                                                                            in  sem_Decl_FusionConv_9)) of
                                                                                                                                                                                                                     { ( sem_Decl_9) | True ->
                                                                                                                                                                                                                     ( _lhsOpatClGam1,sem_Decl_9) }) })))
                                                                                                                                                                                                     in  sem_Decl_FusionConv_8)) of
                                                                                                                                                                                              { ( sem_Decl_8) | True ->
                                                                                                                                                                                              ( _lhsOgenerDataInfoL,_lhsOgenerDataInfoMp,_lhsOkiVarMp,_lhsOpolVarMp,sem_Decl_8) }) }) }) }) }))))))))))
                                                                                                                                                                    in  sem_Decl_FusionConv_7)) of
                                                                                                                                                             { ( sem_Decl_7) | True ->
                                                                                                                                                             ( _lhsOpatKiVarMp,_lhsOpatPolGam,sem_Decl_7) }) }) })))))
                                                                                                                                          in  sem_Decl_FusionConv_6)) of
                                                                                                                                   { ( sem_Decl_6) | True ->
                                                                                                                                   ( _lhsOpatTyKiGam,_lhsOtyTyVarMp,sem_Decl_6) }) }) })))))
                                                                                                                in  sem_Decl_FusionConv_5)) of
                                                                                                         { ( sem_Decl_5) | True ->
                                                                                                         ( _lhsOpatTyGam,sem_Decl_5) }) }))))
                                                                                        in  sem_Decl_FusionConv_4)) of
                                                                                 { ( sem_Decl_4) | True ->
                                                                                 ( _lhsOpredSameScopeCounter,sem_Decl_4) }) }))))
                                                                in  sem_Decl_FusionConv_3)) of
                                                         { ( sem_Decl_3) | True ->
                                                         ( _lhsOgathTyKiSigGam,sem_Decl_3) }) })))
                                         in  sem_Decl_FusionConv_2)) of
                                  { ( sem_Decl_2) | True ->
                                  ( _lhsOgUniq,_lhsOgathKiSigGam,_lhsOhasInstDecl,sem_Decl_2) }) }) }) }) }))))
              in  sem_Decl_FusionConv_1)) of
       { ( sem_Decl_1) | True ->
       ( _lhsOrange,sem_Decl_1) }) }) })

sem_Decl_Class :: Range ->
                  HsName ->
                  T_TyExpr ->
                  T_FuncDeps ->
                  (Maybe HsName) ->
                  T_Decls ->
                  ([(HsName,HsName)]) ->
                  T_Decl

sem_Decl_Class hsrange_ clNm_ tyPrExpr_ funcDeps_ mbDefaultInstNm_ decls_ generDerivs_ | hsrange_ `seq` (clNm_ `seq` (tyPrExpr_ `seq` (funcDeps_ `seq` (mbDefaultInstNm_ `seq` (decls_ `seq` (generDerivs_ `seq` (True))))))) =
    (case (decls_) of
     { ( _declsIrange,decls_1) | True ->
         (case (tyPrExpr_) of
          { ( _tyPrExprIrange,tyPrExpr_1) | True ->
              (case (rangeUnions [hsrange_, _tyPrExprIrange
                                                          , _declsIrange ]) of
               { _range | _range `seq` (True) ->
               (case (_range) of
                { _lhsOrange | _lhsOrange `seq` (True) ->
                (case ((let sem_Decl_Class_1 :: T_Decl_1
                            sem_Decl_Class_1 =
                                (\ _lhsIgUniq
                                   _lhsIgathKiSigGam ->
                                     _lhsIgUniq `seq`
                                     (_lhsIgathKiSigGam `seq`
                                      ((case (let __cont = _lhsIgUniq in seq __cont ( case nextUnique __cont of { (__cont, lUniq) -> case nextUnique __cont of { (__cont, lUniq_17_polCtx) -> case nextUnique __cont of { (__cont, lUniq_9_prTyMeta) -> (__cont,lUniq,lUniq_17_polCtx,lUniq_9_prTyMeta)}}} )) of
                                        { __tup41 | __tup41 `seq` (True) ->
                                        (case (__tup41) of
                                         { (_tyPrExprOgUniq,_,_,_) | _tyPrExprOgUniq `seq` (True) ->
                                         (case (tyPrExpr_1 _tyPrExprOgUniq) of
                                          { ( _tyPrExprIgUniq,tyPrExpr_2) | True ->
                                              (case (_tyPrExprIgUniq) of
                                               { _funcDepsOgUniq | _funcDepsOgUniq `seq` (True) ->
                                               (case (funcDeps_ _funcDepsOgUniq) of
                                                { ( _funcDepsIgUniq,funcDeps_1) | True ->
                                                    (case (_funcDepsIgUniq) of
                                                     { _declsOgUniq | _declsOgUniq `seq` (True) ->
                                                     (case (_lhsIgathKiSigGam) of
                                                      { _declsOgathKiSigGam | _declsOgathKiSigGam `seq` (True) ->
                                                      (case (decls_1 _declsOgUniq _declsOgathKiSigGam) of
                                                       { ( _declsIgUniq,_declsIgathKiSigGam,_declsIhasInstDecl,decls_2) | True ->
                                                           (case (_declsIgUniq) of
                                                            { _lhsOgUniq | _lhsOgUniq `seq` (True) ->
                                                            (case (_declsIgathKiSigGam) of
                                                             { _lhsOgathKiSigGam | _lhsOgathKiSigGam `seq` (True) ->
                                                             (case (False) of
                                                              { _lhsOhasInstDecl | _lhsOhasInstDecl `seq` (True) ->
                                                              (case ((let sem_Decl_Class_2 :: T_Decl_2
                                                                          sem_Decl_Class_2 =
                                                                              (\ _lhsIkiGam ->
                                                                                   _lhsIkiGam `seq`
                                                                                   ((case (_lhsIkiGam) of
                                                                                     { _declsOkiGam | _declsOkiGam `seq` (True) ->
                                                                                     (case (decls_2 _declsOkiGam) of
                                                                                      { ( _declsIgathTyKiSigGam,decls_3) | True ->
                                                                                          (case (_declsIgathTyKiSigGam) of
                                                                                           { _lhsOgathTyKiSigGam | _lhsOgathTyKiSigGam `seq` (True) ->
                                                                                           (case ((let sem_Decl_Class_3 :: T_Decl_3
                                                                                                       sem_Decl_Class_3 =
                                                                                                           (\ _lhsIlexLev
                                                                                                              _lhsIpredSameScopeCounter ->
                                                                                                                _lhsIlexLev `seq`
                                                                                                                (_lhsIpredSameScopeCounter `seq`
                                                                                                                 ((case (_lhsIpredSameScopeCounter+1) of
                                                                                                                   { _lhsOpredSameScopeCounter | _lhsOpredSameScopeCounter `seq` (True) ->
                                                                                                                   (case ((let sem_Decl_Class_4 :: T_Decl_4
                                                                                                                               sem_Decl_Class_4 =
                                                                                                                                   (\ _lhsIpatTyGam
                                                                                                                                      _lhsItyKiSigGam ->
                                                                                                                                        _lhsIpatTyGam `seq`
                                                                                                                                        (_lhsItyKiSigGam `seq`
                                                                                                                                         ((case (hsnClass2Dict clNm_) of
                                                                                                                                           { _dataDictNm | _dataDictNm `seq` (True) ->
                                                                                                                                           (case (gamAdd _dataDictNm (TyGamInfo (appCon _dataDictNm)) _lhsIpatTyGam) of
                                                                                                                                            { _lhsOpatTyGam | _lhsOpatTyGam `seq` (True) ->
                                                                                                                                            (case ((let sem_Decl_Class_5 :: T_Decl_5
                                                                                                                                                        sem_Decl_Class_5 =
                                                                                                                                                            (\ _lhsIpatTyKiGam
                                                                                                                                                               _lhsItyGam
                                                                                                                                                               _lhsItyTyVarMp ->
                                                                                                                                                                 _lhsIpatTyKiGam `seq`
                                                                                                                                                                 (_lhsItyGam `seq`
                                                                                                                                                                  (_lhsItyTyVarMp `seq`
                                                                                                                                                                   ((case (__tup41) of
                                                                                                                                                                     { (_,_lUniq,_,_) | _lUniq `seq` (True) ->
                                                                                                                                                                     (case (mkNewTyVar _lUniq) of
                                                                                                                                                                      { _clsKiVar | _clsKiVar `seq` (True) ->
                                                                                                                                                                      (case (tyKiGamNameSingleton (hsnClass2Kind clNm_) (TyKiGamInfo _clsKiVar) `gamUnion` _lhsIpatTyKiGam) of
                                                                                                                                                                       { _lhsOpatTyKiGam | _lhsOpatTyKiGam `seq` (True) ->
                                                                                                                                                                       (case (_lhsItyTyVarMp) of
                                                                                                                                                                        { _declsOtyTyVarMp | _declsOtyTyVarMp `seq` (True) ->
                                                                                                                                                                        (case (_lhsItyKiSigGam) of
                                                                                                                                                                         { _declsOtyKiSigGam | _declsOtyKiSigGam `seq` (True) ->
                                                                                                                                                                         (case (gamPushNew _lhsItyGam) of
                                                                                                                                                                          { _tyPrExprOtyGam | _tyPrExprOtyGam `seq` (True) ->
                                                                                                                                                                          (case (tyPrExpr_2 _tyPrExprOtyGam) of
                                                                                                                                                                           { ( _tyPrExprIty,_tyPrExprItyGam,tyPrExpr_3) | True ->
                                                                                                                                                                               (case (_tyPrExprItyGam) of
                                                                                                                                                                                { _funcDepsOtyGam | _funcDepsOtyGam `seq` (True) ->
                                                                                                                                                                                (case (funcDeps_1 _funcDepsOtyGam) of
                                                                                                                                                                                 { ( _funcDepsItyGam,funcDeps_2) | True ->
                                                                                                                                                                                     (case (_funcDepsItyGam) of
                                                                                                                                                                                      { _declsOtyGam | _declsOtyGam `seq` (True) ->
                                                                                                                                                                                      (case (_lhsIpatTyGam) of
                                                                                                                                                                                       { _declsOpatTyGam | _declsOpatTyGam `seq` (True) ->
                                                                                                                                                                                       (case (_lhsIlexLev) of
                                                                                                                                                                                        { _declsOlexLev | _declsOlexLev `seq` (True) ->
                                                                                                                                                                                        (case (0) of
                                                                                                                                                                                         { _declsOpredSameScopeCounter | _declsOpredSameScopeCounter `seq` (True) ->
                                                                                                                                                                                         (case (decls_3 _declsOlexLev _declsOpredSameScopeCounter) of
                                                                                                                                                                                          { ( _declsIpredSameScopeCounter,decls_4) | True ->
                                                                                                                                                                                              (case (decls_4 _declsOpatTyGam _declsOtyKiSigGam) of
                                                                                                                                                                                               { ( _declsIpatTyGam,decls_5) | True ->
                                                                                                                                                                                                   (case (emptyGam) of
                                                                                                                                                                                                    { _declsOpatTyKiGam | _declsOpatTyKiGam `seq` (True) ->
                                                                                                                                                                                                    (case (decls_5 _declsOpatTyKiGam _declsOtyGam _declsOtyTyVarMp) of
                                                                                                                                                                                                     { ( _declsIpatTyKiGam,_declsItyTyVarMp,decls_6) | True ->
                                                                                                                                                                                                         (case (_declsItyTyVarMp) of
                                                                                                                                                                                                          { _lhsOtyTyVarMp | _lhsOtyTyVarMp `seq` (True) ->
                                                                                                                                                                                                          (case ((let sem_Decl_Class_6 :: T_Decl_6
                                                                                                                                                                                                                      sem_Decl_Class_6 =
                                                                                                                                                                                                                          (\ _lhsIpatKiVarMp
                                                                                                                                                                                                                             _lhsIpatPolGam
                                                                                                                                                                                                                             _lhsItyKiGam ->
                                                                                                                                                                                                                               _lhsIpatKiVarMp `seq`
                                                                                                                                                                                                                               (_lhsIpatPolGam `seq`
                                                                                                                                                                                                                                (_lhsItyKiGam `seq`
                                                                                                                                                                                                                                 ((case (_lhsIpatKiVarMp) of
                                                                                                                                                                                                                                   { _lhsOpatKiVarMp | _lhsOpatKiVarMp `seq` (True) ->
                                                                                                                                                                                                                                   (case (__tup41) of
                                                                                                                                                                                                                                    { (_,_,_lUniq_17_polCtx,_) | _lUniq_17_polCtx `seq` (True) ->
                                                                                                                                                                                                                                    (case (appUnArr _tyPrExprIty) of
                                                                                                                                                                                                                                     { __tup38 | __tup38 `seq` (True) ->
                                                                                                                                                                                                                                     (case (__tup38) of
                                                                                                                                                                                                                                      { (_,_hdPrTy) | _hdPrTy `seq` (True) ->
                                                                                                                                                                                                                                      (case (tyPredMatchNmArgs _hdPrTy) of
                                                                                                                                                                                                                                       { __tup39 | __tup39 `seq` (True) ->
                                                                                                                                                                                                                                       (case (__tup39) of
                                                                                                                                                                                                                                        { (_prClsNm,_) | _prClsNm `seq` (True) ->
                                                                                                                                                                                                                                        (case (mkPolVar _lUniq_17_polCtx) of
                                                                                                                                                                                                                                         { _polCtxVar | _polCtxVar `seq` (True) ->
                                                                                                                                                                                                                                         (case (_polCtxVar) of
                                                                                                                                                                                                                                          { _tyPrExprOknPolCtx | _tyPrExprOknPolCtx `seq` (True) ->
                                                                                                                                                                                                                                          (case (tyPrExpr_3 _tyPrExprOknPolCtx) of
                                                                                                                                                                                                                                           { ( _tyPrExprIpolVarL,tyPrExpr_4) | True ->
                                                                                                                                                                                                                                               (case (_tyPrExprIpolVarL `appArr` _polCtxVar) of
                                                                                                                                                                                                                                                { _polSig | _polSig `seq` (True) ->
                                                                                                                                                                                                                                                (case (gamAdd (hsnClass2Polarity _prClsNm) (mkPGI _polSig) _lhsIpatPolGam) of
                                                                                                                                                                                                                                                 { _lhsOpatPolGam | _lhsOpatPolGam `seq` (True) ->
                                                                                                                                                                                                                                                 (case ((let sem_Decl_Class_7 :: T_Decl_7
                                                                                                                                                                                                                                                             sem_Decl_Class_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
                                                                                                                                                                                                                                                                               { _declsOtyKiGlobFreeTvarS | _declsOtyKiGlobFreeTvarS `seq` (True) ->
                                                                                                                                                                                                                                                                               (case (_lhsItyKiGam) of
                                                                                                                                                                                                                                                                                { _tyPrExprOtyKiGam | _tyPrExprOtyKiGam `seq` (True) ->
                                                                                                                                                                                                                                                                                (case (_lhsIpolVarMp) of
                                                                                                                                                                                                                                                                                 { _tyPrExprOpolVarMp | _tyPrExprOpolVarMp `seq` (True) ->
                                                                                                                                                                                                                                                                                 (case (_lhsIpolGam) of
                                                                                                                                                                                                                                                                                  { _tyPrExprOpolGam | _tyPrExprOpolGam `seq` (True) ->
                                                                                                                                                                                                                                                                                  (case (tyPrExpr_4 _tyPrExprOpolGam _tyPrExprOpolVarMp) of
                                                                                                                                                                                                                                                                                   { ( _tyPrExprImbStrictness,_tyPrExprIpolVarMp,tyPrExpr_5) | True ->
                                                                                                                                                                                                                                                                                       (case (tyPrExpr_5 _tyPrExprOtyKiGam) of
                                                                                                                                                                                                                                                                                        { ( _tyPrExprIintlTyKiGam,_tyPrExprItyKiGam,tyPrExpr_6) | True ->
                                                                                                                                                                                                                                                                                            (case (_tyPrExprItyKiGam) of
                                                                                                                                                                                                                                                                                             { _funcDepsOtyKiGam | _funcDepsOtyKiGam `seq` (True) ->
                                                                                                                                                                                                                                                                                             (case (funcDeps_2 _funcDepsOtyKiGam) of
                                                                                                                                                                                                                                                                                              { ( _funcDepsItyKiGam,funcDeps_3) | True ->
                                                                                                                                                                                                                                                                                                  (case (_funcDepsItyKiGam) of
                                                                                                                                                                                                                                                                                                   { _declsOtyKiGam | _declsOtyKiGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                   (case (snd $ pscpEnter _lhsIpredSameScopeCounter _lhsIpredScope) of
                                                                                                                                                                                                                                                                                                    { _predScope | _predScope `seq` (True) ->
                                                                                                                                                                                                                                                                                                    (case (_predScope) of
                                                                                                                                                                                                                                                                                                     { _declsOpredScope | _declsOpredScope `seq` (True) ->
                                                                                                                                                                                                                                                                                                     (case (_tyPrExprIpolVarMp) of
                                                                                                                                                                                                                                                                                                      { _declsOpolVarMp | _declsOpolVarMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                      (case (_lhsIpatPolGam) of
                                                                                                                                                                                                                                                                                                       { _declsOpatPolGam | _declsOpatPolGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                       (case (_lhsIopts) of
                                                                                                                                                                                                                                                                                                        { _declsOopts | _declsOopts `seq` (True) ->
                                                                                                                                                                                                                                                                                                        (case (_lhsIkiVarMp) of
                                                                                                                                                                                                                                                                                                         { _tyPrExprOkiVarMp | _tyPrExprOkiVarMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                         (case (tyPrExpr_6 _tyPrExprOkiVarMp) of
                                                                                                                                                                                                                                                                                                          { ( _tyPrExprIgathTyVarPolGam,_tyPrExprIki,_tyPrExprIkiVarMp,_tyPrExprIpol,_tyPrExprItyVarWildMp,tyPrExpr_7) | True ->
                                                                                                                                                                                                                                                                                                              (case (_tyPrExprIkiVarMp) of
                                                                                                                                                                                                                                                                                                               { _declsOkiVarMp | _declsOkiVarMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                               (case (_lhsIgenerDataInfoMp) of
                                                                                                                                                                                                                                                                                                                { _declsOgenerDataInfoMp | _declsOgenerDataInfoMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                (case (emptyVarMp) of
                                                                                                                                                                                                                                                                                                                 { _declsOpatKiVarMp | _declsOpatKiVarMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                 (case (gamPushGam _tyPrExprIgathTyVarPolGam _lhsIpolGam) of
                                                                                                                                                                                                                                                                                                                  { _declsOpolGam | _declsOpolGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                  (case (Just _polCtxVar) of
                                                                                                                                                                                                                                                                                                                   { _declsOmbKnPolCtx | _declsOmbKnPolCtx `seq` (True) ->
                                                                                                                                                                                                                                                                                                                   (case (decls_6 _declsOpatKiVarMp _declsOpatPolGam _declsOtyKiGam) of
                                                                                                                                                                                                                                                                                                                    { ( _declsIpatKiVarMp,_declsIpatPolGam,decls_7) | True ->
                                                                                                                                                                                                                                                                                                                        (case (decls_7 _declsOgenerDataInfoMp _declsOkiVarMp _declsOmbKnPolCtx _declsOopts _declsOpolGam _declsOpolVarMp _declsOpredScope _declsOtyKiGlobFreeTvarS) of
                                                                                                                                                                                                                                                                                                                         { ( _declsIgenerDataInfoL,_declsIgenerDataInfoMp,_declsIkiVarMp,_declsIpolVarMp,decls_8) | True ->
                                                                                                                                                                                                                                                                                                                             (case (_declsIgenerDataInfoL) of
                                                                                                                                                                                                                                                                                                                              { _lhsOgenerDataInfoL | _lhsOgenerDataInfoL `seq` (True) ->
                                                                                                                                                                                                                                                                                                                              (case (_declsIgenerDataInfoMp) of
                                                                                                                                                                                                                                                                                                                               { _lhsOgenerDataInfoMp | _lhsOgenerDataInfoMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                               (case (_declsIkiVarMp) of
                                                                                                                                                                                                                                                                                                                                { _lhsOkiVarMp | _lhsOkiVarMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                (case (_declsIpolVarMp) of
                                                                                                                                                                                                                                                                                                                                 { _lhsOpolVarMp | _lhsOpolVarMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                 (case ((let sem_Decl_Class_8 :: T_Decl_8
                                                                                                                                                                                                                                                                                                                                             sem_Decl_Class_8 =
                                                                                                                                                                                                                                                                                                                                                 (\ _lhsIpatClGam1 ->
                                                                                                                                                                                                                                                                                                                                                      _lhsIpatClGam1 `seq`
                                                                                                                                                                                                                                                                                                                                                      ((case (emptyCLGI { clgiDfltDictNm = maybe (uidHNm _lUniq) id mbDefaultInstNm_
                                                                                                                                                                                                                                                                                                                                                                        , clgiGenerDerivableL = generDerivs_
                                                                                                                                                                                                                                                                                                                                                                        }) of
                                                                                                                                                                                                                                                                                                                                                        { _clgi1 | _clgi1 `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                        (case (gamAdd clNm_ _clgi1 _lhsIpatClGam1) of
                                                                                                                                                                                                                                                                                                                                                         { _lhsOpatClGam1 | _lhsOpatClGam1 `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                         (case ((let sem_Decl_Class_9 :: T_Decl_9
                                                                                                                                                                                                                                                                                                                                                                     sem_Decl_Class_9 =
                                                                                                                                                                                                                                                                                                                                                                         (\ _lhsIfinKiVarMp
                                                                                                                                                                                                                                                                                                                                                                            _lhsIfinTyKiGam
                                                                                                                                                                                                                                                                                                                                                                            _lhsIpatClGam2
                                                                                                                                                                                                                                                                                                                                                                            _lhsItyTyTySigFreeTvarS ->
                                                                                                                                                                                                                                                                                                                                                                              _lhsIfinKiVarMp `seq`
                                                                                                                                                                                                                                                                                                                                                                              (_lhsIfinTyKiGam `seq`
                                                                                                                                                                                                                                                                                                                                                                               (_lhsIpatClGam2 `seq`
                                                                                                                                                                                                                                                                                                                                                                                (_lhsItyTyTySigFreeTvarS `seq`
                                                                                                                                                                                                                                                                                                                                                                                 ((case (_lhsIpatClGam2) of
                                                                                                                                                                                                                                                                                                                                                                                   { _declsOpatClGam2 | _declsOpatClGam2 `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                   (case (_lhsIpatClGam1) of
                                                                                                                                                                                                                                                                                                                                                                                    { _declsOpatClGam1 | _declsOpatClGam1 `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                    (case (_lhsIfinTyKiGam) of
                                                                                                                                                                                                                                                                                                                                                                                     { _declsOfinTyKiGam | _declsOfinTyKiGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                     (case (_lhsIfinKiVarMp) of
                                                                                                                                                                                                                                                                                                                                                                                      { _declsOfinKiVarMp | _declsOfinKiVarMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                      (case (varFreeSet (gamTop _tyPrExprItyGam) `Set.union` _lhsItyTyTySigFreeTvarS) of
                                                                                                                                                                                                                                                                                                                                                                                       { _declsOtyTyTySigFreeTvarS | _declsOtyTyTySigFreeTvarS `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                       (case (_lhsIpatClGam2) of
                                                                                                                                                                                                                                                                                                                                                                                        { _declsOclGam | _declsOclGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                        (case (decls_8 _declsOpatClGam1) of
                                                                                                                                                                                                                                                                                                                                                                                         { ( _declsIpatClGam1,decls_9) | True ->
                                                                                                                                                                                                                                                                                                                                                                                             (case (decls_9 _declsOfinKiVarMp _declsOfinTyKiGam _declsOpatClGam2 _declsOtyTyTySigFreeTvarS) of
                                                                                                                                                                                                                                                                                                                                                                                              { ( _declsIpatClGam2,decls_10) | True ->
                                                                                                                                                                                                                                                                                                                                                                                                  (case (emptyGam) of
                                                                                                                                                                                                                                                                                                                                                                                                   { _declsOgathDataGam | _declsOgathDataGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                   (case (decls_10 _declsOclGam _declsOgathDataGam) of
                                                                                                                                                                                                                                                                                                                                                                                                    { ( _declsIgathDataGam,_declsIgathDeclDataGam,_declsIgathTySigGam,_declsIgathTySigVarMp,decls_11) | True ->
                                                                                                                                                                                                                                                                                                                                                                                                        (case (_declsIgathTySigVarMp `varUpd` _declsIgathTySigGam) of
                                                                                                                                                                                                                                                                                                                                                                                                         { _lSigGam | _lSigGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                         (case (valGamMapTy (\t -> [_hdPrTy] `appArr` t) _lSigGam) of
                                                                                                                                                                                                                                                                                                                                                                                                          { _clsTySigGam | _clsTySigGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                          (case (if ehcCfgInstFldHaveSelf _lhsIopts then _clsTySigGam else _lSigGam) of
                                                                                                                                                                                                                                                                                                                                                                                                           { _clsTySigDictGam | _clsTySigDictGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                           (case ([ (Just n, vgiTy vgi) | (n,vgi) <- gamToAssocL _clsTySigDictGam ]) of
                                                                                                                                                                                                                                                                                                                                                                                                            { _clsFldTyL | _clsFldTyL `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                            (case (__tup38) of
                                                                                                                                                                                                                                                                                                                                                                                                             { (_ctxtPrTyL,_) | _ctxtPrTyL `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                             (case (zipWith (\t n -> (Just n, tyDict t)) _ctxtPrTyL $ tyPrLToSupNmL _ctxtPrTyL) of
                                                                                                                                                                                                                                                                                                                                                                                                              { _supClsFldTyL | _supClsFldTyL `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                              (case (_clsFldTyL ++ _supClsFldTyL) of
                                                                                                                                                                                                                                                                                                                                                                                                               { _clsAllFldTyL | _clsAllFldTyL `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                               (case (mkClassCTag _dataDictNm (length _clsAllFldTyL)) of
                                                                                                                                                                                                                                                                                                                                                                                                                { _dataDictTag | _dataDictTag `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                (case (if ehcCfgClassViaRec _lhsIopts then CTagRec else _dataDictTag) of
                                                                                                                                                                                                                                                                                                                                                                                                                 { _dictTag | _dictTag `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                 (case (tyDict _hdPrTy) of
                                                                                                                                                                                                                                                                                                                                                                                                                  { _dataDictTy | _dataDictTy `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                  (case (recRec $ assocLMapKey fromJust _clsAllFldTyL) of
                                                                                                                                                                                                                                                                                                                                                                                                                   { _clsTyRec | _clsTyRec `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                   (case (\clgi -> clgi
                                                                                                                                                                                                                                                                                                                                                                                                                                 { clgiPrToEvidRecTy      = tyQuantifyClosed $ [_hdPrTy] `appArr` _clsTyRec
                                                                                                                                                                                                                                                                                                                                                                                                                                 , clgiPrToEvidDataTy = tyQuantifyClosed $ [_hdPrTy] `appArr` _dataDictTy
                                                                                                                                                                                                                                                                                                                                                                                                                                 , clgiRuleTy         = tyQuantifyClosed _tyPrExprIty
                                                                                                                                                                                                                                                                                                                                                                                                                                 , clgiDictTag        = _dictTag
                                                                                                                                                                                                                                                                                                                                                                                                                                 }) of
                                                                                                                                                                                                                                                                                                                                                                                                                    { _clgiUpd | _clgiUpd `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                    (case (gamTopUpdate _clgiUpd clNm_ _lhsIpatClGam2) of
                                                                                                                                                                                                                                                                                                                                                                                                                     { _lhsOpatClGam2 | _lhsOpatClGam2 `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                     (case ((let sem_Decl_Class_10 :: T_Decl_10
                                                                                                                                                                                                                                                                                                                                                                                                                                 sem_Decl_Class_10 =
                                                                                                                                                                                                                                                                                                                                                                                                                                     (\ _lhsIclGam
                                                                                                                                                                                                                                                                                                                                                                                                                                        _lhsIgathDataGam ->
                                                                                                                                                                                                                                                                                                                                                                                                                                          _lhsIclGam `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                                          (_lhsIgathDataGam `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                                           ((case (_lhsIgathDataGam) of
                                                                                                                                                                                                                                                                                                                                                                                                                                             { _lhsOgathDataGam | _lhsOgathDataGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                             (case (mkDataConstrTys1 (assocLElts _clsAllFldTyL, _clsAllFldTyL) _dataDictTy) of
                                                                                                                                                                                                                                                                                                                                                                                                                                              { __tup40 | __tup40 `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                              (case (__tup40) of
                                                                                                                                                                                                                                                                                                                                                                                                                                               { (_dataDictConTy,_) | _dataDictConTy `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                               (case (if ehcCfgClassViaRec _lhsIopts
                                                                                                                                                                                                                                                                                                                                                                                                                                                      then emptyGam
                                                                                                                                                                                                                                                                                                                                                                                                                                                      else let dgi = mkDGIPlain _dataDictNm dty _clsKiVar [_dataDictNm] (_dataDictNm `Map.singleton` dti)
                                                                                                                                                                                                                                                                                                                                                                                                                                                               dty = [_dataDictTy] `appArr` recSum [(_dataDictNm,_clsTyRec)]
                                                                                                                                                                                                                                                                                                                                                                                                                                                               fldTyL = _clsAllFldTyL
                                                                                                                                                                                                                                                                                                                                                                                                                                                               (fldMp, _, fldRefL) = mkFldRefAndMp fldTyL
                                                                                                                                                                                                                                                                                                                                                                                                                                                               dti = emptyDataTagInfo
                                                                                                                                                                                                                                                                                                                                                                                                                                                                       { dtiCTag = _dataDictTag
                                                                                                                                                                                                                                                                                                                                                                                                                                                                       , dtiConNm = _dataDictNm
                                                                                                                                                                                                                                                                                                                                                                                                                                                                       , dtiFldTyL = fldTyL
                                                                                                                                                                                                                                                                                                                                                                                                                                                                       , dtiFldRefL = assocLElts fldRefL
                                                                                                                                                                                                                                                                                                                                                                                                                                                                       , dtiFldMp = fldMp
                                                                                                                                                                                                                                                                                                                                                                                                                                                                       , dtiConTy = _dataDictConTy
                                                                                                                                                                                                                                                                                                                                                                                                                                                                       , dtiConFldAnnL = replicate (length _clsAllFldTyL) emptyDataConFldAnnInfo
                                                                                                                                                                                                                                                                                                                                                                                                                                                                       }
                                                                                                                                                                                                                                                                                                                                                                                                                                                           in  gamSingleton _dataDictNm dgi) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                { _lhsOgathDeclDataGam | _lhsOgathDeclDataGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                (case (valGamMapTy tyQuantifyClosed _clsTySigGam) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                 { _lhsOgathTySigGam | _lhsOgathTySigGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                 (case (_declsIgathTySigVarMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                  { _lhsOgathTySigVarMp | _lhsOgathTySigVarMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                  (case ((let sem_Decl_Class_11 :: T_Decl_11
                                                                                                                                                                                                                                                                                                                                                                                                                                                              sem_Decl_Class_11 =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (\ _lhsIdataGam ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                       _lhsIdataGam `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                       ((case ([ n | (Just n, _) <- _supClsFldTyL ]) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                         { _supClsFldNmL | _supClsFldNmL `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                         (case (let off n = tyRecOffset n _clsTyRec
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                in  (             map tyPred _ctxtPrTyL
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ,             tyPred     _hdPrTy
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    , zipWith (\p n -> RedHow_BySuperClass n (off n) _dictTag)          _ctxtPrTyL _supClsFldNmL
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    )) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          { _chrClassDecl | _chrClassDecl `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          (case (Seq.singleton _chrClassDecl) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                           { _lhsOchrClassDeclSq | _lhsOchrClassDeclSq `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                           (case (_lhsIdataGam) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            { _declsOdataGam | _declsOdataGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (case (decls_11 _declsOdataGam) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                             { ( _declsIchrClassDeclSq,_declsIchrInstDeclSq,_declsIgathClDfGam,decls_12) | True ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 (case (_declsIchrInstDeclSq) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  { _lhsOchrInstDeclSq | _lhsOchrInstDeclSq `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (case (_declsIgathClDfGam) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   { _lhsOgathClDfGam | _lhsOgathClDfGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   (case ((let sem_Decl_Class_12 :: T_Decl_12
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               sem_Decl_Class_12 =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   (\ _lhsIpatTyVarMp
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      _lhsIpatValGam
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      _lhsItvKiVarMp
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      _lhsItySigGam
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      _lhsItySigVarMp ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _lhsIpatTyVarMp `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (_lhsIpatValGam `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         (_lhsItvKiVarMp `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          (_lhsItySigGam `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           (_lhsItySigVarMp `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ((case (_lhsItySigVarMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              { _declsOtySigVarMp | _declsOtySigVarMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              (case (_lhsItySigGam) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               { _declsOtySigGam | _declsOtySigGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               (case (_lhsItvKiVarMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                { _declsOtvKiVarMp | _declsOtvKiVarMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (case (_lhsIpatValGam) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 { _declsOpatValGam | _declsOpatValGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 (case (_lhsIpatTyVarMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  { _declsOpatTyVarMp | _declsOpatTyVarMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (case (decls_12 _declsOpatTyVarMp _declsOpatValGam _declsOtvKiVarMp _declsOtySigGam _declsOtySigVarMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   { ( _declsIpatTyVarMp,_declsIpatValGam,decls_13) | True ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       (case (_declsIpatTyVarMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        { _lhsOpatTyVarMp | _lhsOpatTyVarMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (case (__tup40) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         { (_,_dataDictConProdTy) | _dataDictConProdTy `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         (case (mkDataConstrTys2 (tvarKi _lhsIfinTyKiGam _tyPrExprIintlTyKiGam _lhsItvKiVarMp emptyVarMp) _dataDictConProdTy _dataDictTy) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          { _dataDictQuUnConTy | _dataDictQuUnConTy `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          (case (mkDataConstrValGam _dataDictNm _dataDictConTy _dataDictQuUnConTy `gamUnion` _lhsIpatValGam) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           { _lhsOpatValGam | _lhsOpatValGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           (case ((let sem_Decl_Class_13 :: T_Decl_13
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       sem_Decl_Class_13 =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           (\ _lhsIchrStore
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              _lhsIclDfGam
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              _lhsItyTyGlobFreeTvarS
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              _lhsItyVarMp
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              _lhsIvalGam
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              _lhsIvalTyGlobFreeTvarS ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _lhsIchrStore `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (_lhsIclDfGam `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 (_lhsItyTyGlobFreeTvarS `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (_lhsItyVarMp `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   (_lhsIvalGam `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (_lhsIvalTyGlobFreeTvarS `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     ((case (_lhsIvalTyGlobFreeTvarS) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       { _declsOvalTyGlobFreeTvarS | _declsOvalTyGlobFreeTvarS `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       (case (_lhsIvalGam) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        { _declsOvalGam | _declsOvalGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (case (_lhsItyVarMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         { _declsOtyVarMp | _declsOtyVarMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         (case (_lhsIclDfGam) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          { _declsOclDfGam | _declsOclDfGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          (case (_lhsIchrStore) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           { _declsOchrStore | _declsOchrStore `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           (case (varFreeSet (gamTop _tyPrExprItyGam) `Set.union` _lhsItyTyGlobFreeTvarS) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            { _declsOtyTyGlobFreeTvarS | _declsOtyTyGlobFreeTvarS `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (case (decls_13 _declsOchrStore _declsOclDfGam _declsOtyTyGlobFreeTvarS _declsOtyVarMp _declsOvalGam _declsOvalTyGlobFreeTvarS) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             { ( _declsIgathCnstrMp,_declsIgathRangeMp,_declsIintlTyKiGam,_declsInoLetQuantTyVarIdS,_declsIscopeGam,_declsItyVarMp,decls_14) | True ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 (case (_declsIgathCnstrMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  { _lhsOgathCnstrMp | _lhsOgathCnstrMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (case (_declsIgathRangeMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   { _lhsOgathRangeMp | _lhsOgathRangeMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   (case (_tyPrExprIintlTyKiGam `gamUnion` _declsIintlTyKiGam) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    { _lhsOintlTyKiGam | _lhsOintlTyKiGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (case (_declsInoLetQuantTyVarIdS) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     { _lhsOnoLetQuantTyVarIdS | _lhsOnoLetQuantTyVarIdS `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     (case (_declsIscopeGam) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      { _lhsOscopeGam | _lhsOscopeGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      (case (_declsItyVarMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       { _lhsOtyVarMp | _lhsOtyVarMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       (case ((let sem_Decl_Class_14 :: T_Decl_14
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   sem_Decl_Class_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
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        { _declsOsysfEnv | _declsOsysfEnv `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (case (_lhsIrangeMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         { _declsOrangeMp | _declsOrangeMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         (case (_lhsIfinValGam) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          { _declsOfinValGam | _declsOfinValGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          (case (_lhsIfinTyVarMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           { _declsOfinTyVarMp | _declsOfinTyVarMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           (case (_lhsItr) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            { _declsOtr | _declsOtr `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (case (_lhsImoduleNm) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             { _declsOmoduleNm | _declsOmoduleNm `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             (case (_lhsIkiSigGam) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              { _declsOkiSigGam | _declsOkiSigGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              (case (_lhsIisStrict) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               { _declsOisStrict | _declsOisStrict `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               (case (_lhsIchrScopeBindMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                { _declsOchrScopeBindMp | _declsOchrScopeBindMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (case (_lhsIchrEvidBindMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 { _declsOchrEvidBindMp | _declsOchrEvidBindMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 (case (_lhsIcSubst) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  { _declsOcSubst | _declsOcSubst `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (case (decls_14 _declsOcSubst _declsOchrEvidBindMp _declsOchrScopeBindMp _declsOfinTyVarMp _declsOfinValGam _declsOisStrict _declsOkiSigGam _declsOmoduleNm _declsOrangeMp _declsOsysfEnv _declsOtr) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   { ( _declsIallErrSq,_declsIbangEvalL,_declsIcSubst,_declsIerrSq,_declsIffeCBindL,_declsIffiCBindL,_declsIgathHiddenExports,_declsIgathLamMp,_declsIgathMentrelFilterMp,_declsIgathTvKiVarMp,_declsIorphanS,_declsIpp,_declsIppAST,_declsItrpp,_declsItyCBindL,_declsIvalCBindL) | True ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       (case (_lhsIvalTyGlobFreeTvarS) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        { _funcDepsOvalTyGlobFreeTvarS | _funcDepsOvalTyGlobFreeTvarS `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (case (_lhsItyTyTySigFreeTvarS) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         { _funcDepsOtyTyTySigFreeTvarS | _funcDepsOtyTyTySigFreeTvarS `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         (case (_lhsItyTyGlobFreeTvarS) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          { _funcDepsOtyTyGlobFreeTvarS | _funcDepsOtyTyGlobFreeTvarS `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          (case (_lhsItyKiGlobFreeTvarS) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           { _funcDepsOtyKiGlobFreeTvarS | _funcDepsOtyKiGlobFreeTvarS `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           (case (_lhsItr) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            { _funcDepsOtr | _funcDepsOtr `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (case (_lhsIsysfEnv) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             { _funcDepsOsysfEnv | _funcDepsOsysfEnv `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             (case (_lhsIopts) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              { _funcDepsOopts | _funcDepsOopts `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              (case (_lhsImoduleNm) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               { _funcDepsOmoduleNm | _funcDepsOmoduleNm `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               (case (_lhsIfinTyVarMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                { _funcDepsOfinTyVarMp | _funcDepsOfinTyVarMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (case (_lhsIfinTyKiGam) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 { _funcDepsOfinTyKiGam | _funcDepsOfinTyKiGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 (case (_lhsIfinKiVarMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  { _funcDepsOfinKiVarMp | _funcDepsOfinKiVarMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (case (appUnAppArgs . predTy . tyPred $ _hdPrTy) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   { _clsTyArgs | _clsTyArgs `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   (case (_clsTyArgs) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    { _funcDepsOclsTyArgs | _funcDepsOclsTyArgs `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (case (funcDeps_3 _funcDepsOclsTyArgs _funcDepsOfinKiVarMp _funcDepsOfinTyKiGam _funcDepsOfinTyVarMp _funcDepsOmoduleNm _funcDepsOopts _funcDepsOsysfEnv _funcDepsOtr _funcDepsOtyKiGlobFreeTvarS _funcDepsOtyTyGlobFreeTvarS _funcDepsOtyTyTySigFreeTvarS _funcDepsOvalTyGlobFreeTvarS) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     { ( _funcDepsIallErrSq,_funcDepsIerrSq,_funcDepsIfuncDeps,_funcDepsIgathMentrelFilterMp,_funcDepsIpp,_funcDepsIppAST,_funcDepsIppL,_funcDepsIrange,_funcDepsItrpp) | True ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         (case (_lhsIpatClGam2) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          { _tyPrExprOclGam | _tyPrExprOclGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          (case (tyPrExpr_7 _tyPrExprOclGam) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           { ( _tyPrExprIevTy,tyPrExpr_8) | True ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               (case (_lhsIvalTyGlobFreeTvarS) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                { _tyPrExprOvalTyGlobFreeTvarS | _tyPrExprOvalTyGlobFreeTvarS `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (case (_lhsItyTyTySigFreeTvarS) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 { _tyPrExprOtyTyTySigFreeTvarS | _tyPrExprOtyTyTySigFreeTvarS `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 (case (_lhsItyTyGlobFreeTvarS) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  { _tyPrExprOtyTyGlobFreeTvarS | _tyPrExprOtyTyGlobFreeTvarS `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (case (_lhsItyKiGlobFreeTvarS) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   { _tyPrExprOtyKiGlobFreeTvarS | _tyPrExprOtyKiGlobFreeTvarS `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   (case (_lhsItr) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    { _tyPrExprOtr | _tyPrExprOtr `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (case (_lhsIsysfEnv) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     { _tyPrExprOsysfEnv | _tyPrExprOsysfEnv `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     (case (_lhsIopts) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      { _tyPrExprOopts | _tyPrExprOopts `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      (case (_lhsImoduleNm) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       { _tyPrExprOmoduleNm | _tyPrExprOmoduleNm `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       (case (_lhsIkiGam) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        { _tyPrExprOkiGam | _tyPrExprOkiGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (case (_lhsIfinTyVarMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         { _tyPrExprOfinTyVarMp | _tyPrExprOfinTyVarMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         (case (_lhsIfinTyKiGam) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          { _tyPrExprOfinTyKiGam | _tyPrExprOfinTyKiGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          (case (_lhsIfinKiVarMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           { _tyPrExprOfinKiVarMp | _tyPrExprOfinKiVarMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           (case (tyPrExpr_8 _tyPrExprOfinKiVarMp _tyPrExprOfinTyKiGam _tyPrExprOfinTyVarMp _tyPrExprOkiGam _tyPrExprOmoduleNm _tyPrExprOopts _tyPrExprOsysfEnv _tyPrExprOtr _tyPrExprOtyKiGlobFreeTvarS _tyPrExprOtyTyGlobFreeTvarS _tyPrExprOtyTyTySigFreeTvarS _tyPrExprOvalTyGlobFreeTvarS) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            { ( _tyPrExprIallErrSq,_tyPrExprIappArgPPL,_tyPrExprIappFunNm,_tyPrExprIappFunPP,_tyPrExprIclMissNmS,_tyPrExprIclNmS,_tyPrExprIerrSq,_tyPrExprIgathMentrelFilterMp,_tyPrExprIpp,_tyPrExprIppAST,_tyPrExprItrpp,_tyPrExprItyWildL) | True ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (case (_tyPrExprIallErrSq `Seq.union` _funcDepsIallErrSq `Seq.union` _declsIallErrSq) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 { _lhsOallErrSq | _lhsOallErrSq `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 (case (_declsIbangEvalL) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  { _lhsObangEvalL | _lhsObangEvalL `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (case (_declsIcSubst) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   { _lhsOcSubst | _lhsOcSubst `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   (case (_tyPrExprIerrSq `Seq.union` _funcDepsIerrSq `Seq.union` _declsIerrSq) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    { _lhsOerrSq | _lhsOerrSq `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (case (_declsIffeCBindL) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     { _lhsOffeCBindL | _lhsOffeCBindL `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     (case (_declsIffiCBindL) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      { _lhsOffiCBindL | _lhsOffiCBindL `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      (case (Seq.fromList [ (dflt,IdOcc_Val) | (_,dflt) <- generDerivs_ ]) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       { _lhsOgathHiddenExports | _lhsOgathHiddenExports `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       (case (_declsIgathLamMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        { _lhsOgathLamMp | _lhsOgathLamMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (case (_tyPrExprIgathMentrelFilterMp `mentrelFilterMpUnion` _funcDepsIgathMentrelFilterMp `mentrelFilterMpUnion` _declsIgathMentrelFilterMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         { _lhsOgathMentrelFilterMp | _lhsOgathMentrelFilterMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         (case (_declsIgathTvKiVarMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          { _lhsOgathTvKiVarMp | _lhsOgathTvKiVarMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          (case (_declsIorphanS) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           { _lhsOorphanS | _lhsOorphanS `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           (case ("class"     >#< _tyPrExprIpp
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              >#< "|" >#< ppListSep "" "" ", " _funcDepsIppL
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              >#< "where"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              >-< indent 2 (_declsIpp
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            >-< ppCmt (ppAssocL generDerivs_)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           )) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            { _pp | _pp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (case (_pp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             { _lhsOpp | _lhsOpp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             (case (_clgiUpd _clgi1) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              { _clgi2 | _clgi2 `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              (case ((_lhsItr TraceOn_EhClsGam $ [clNm_ >#< " = Class"] ++ [ "clgi1=" >#< _clgi1, "clgi2=" >#< _clgi2, "patClGam2=" >#< ppGam _lhsIpatClGam2 ])) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               { _trppHere | _trppHere `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               (case (ppNestTrPP _lhsIopts ["Decl","Class"] [] [ _tyPrExprIppAST
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               , _funcDepsIppAST
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               , _declsIppAST] _trppHere) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                { _ppAST | _ppAST `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (case (_ppAST) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 { _lhsOppAST | _lhsOppAST `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 (case (_trppHere
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        >< _tyPrExprItrpp
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        >< _funcDepsItrpp
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        >< _declsItrpp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  { _trpp | _trpp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (case (_trpp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   { _lhsOtrpp | _lhsOtrpp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   (case (_declsItyCBindL) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    { _lhsOtyCBindL | _lhsOtyCBindL `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (case (let  x = mkHNm "x"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                vx = acoreVar x
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                xStrict = hsnUniqifyEval x
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                mkSel n = acoreSatSelsCaseMetaTy
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ((emptyRCEEnv _lhsIopts) {rceDataGam = _lhsIdataGam}) (Just (xStrict,(acoreTyErr $ "EH.ToCore.Decl.Class.mkSel: " ++ show n))) CMetaVal_Dict vx _dictTag
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            [(n,acoreTyErr $ "EH.ToCore.Decl.Class.mkSel: " ++ show n,      cdictOffset n _clsTyRec)] Nothing (acoreVar n)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                mkApp = if ehcCfgInstFldHaveSelf _lhsIopts
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        then (\f -> acore1App f vx)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        else id
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                dDflt
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  = [acoreBind1Ty nDflt (acoreTyErr $ "EH.ToCore.Decl.Class.dDflt: " ++ show nDflt) (acoreLam1Ty nD (acoreTyErr "EH.ToCore.Decl.Class.dDflt") d)]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  where nDflt = clgiDfltDictNm _clgi2
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        d = acoreTagTupTy _dictTag (acoreTyErr "EH.ToCore.Decl.Class.d") (replicate (length $ snd $ tyRecExts $ _clsTyRec) (acoreBuiltinUndefined _lhsIopts))
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        nD = hsnUniqify HsNameUniqifier_SelfDict nDflt
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           in   (maybe dDflt (const []) mbDefaultInstNm_)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ++ [ acoreBind1CatTy CBindCateg_Plain n
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       (SysF.ty2TyC _lhsIopts _lhsIsysfEnv $ tyQuantifyClosed $ [_dataDictTy] `appArr` t)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     $ acoreLam1Ty x (acoreTyErr "EH.ToCore.Decl.Class.valCBindL")
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     $ mkApp
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     $ mkSel n
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | (Just n,t) <- _clsFldTyL
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   ]) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     { _lhsOvalCBindL | _lhsOvalCBindL `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     ( _lhsOallErrSq,_lhsObangEvalL,_lhsOcSubst,_lhsOerrSq,_lhsOffeCBindL,_lhsOffiCBindL,_lhsOgathHiddenExports,_lhsOgathLamMp,_lhsOgathMentrelFilterMp,_lhsOgathTvKiVarMp,_lhsOorphanS,_lhsOpp,_lhsOppAST,_lhsOtrpp,_lhsOtyCBindL,_lhsOvalCBindL) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) })))))))))))))
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               in  sem_Decl_Class_14)) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        { ( sem_Decl_14) | True ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ( _lhsOgathCnstrMp,_lhsOgathRangeMp,_lhsOintlTyKiGam,_lhsOnoLetQuantTyVarIdS,_lhsOscopeGam,_lhsOtyVarMp,sem_Decl_14) }) }) }) }) }) }) }) }) }) }) }) }) }) }))))))))
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   in  sem_Decl_Class_13)) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            { ( sem_Decl_13) | True ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ( _lhsOpatTyVarMp,_lhsOpatValGam,sem_Decl_13) }) }) }) }) }) }) }) }) }) }) })))))))
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           in  sem_Decl_Class_12)) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    { ( sem_Decl_12) | True ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ( _lhsOchrClassDeclSq,_lhsOchrInstDeclSq,_lhsOgathClDfGam,sem_Decl_12) }) }) }) }) }) }) }) })))
                                                                                                                                                                                                                                                                                                                                                                                                                                                          in  sem_Decl_Class_11)) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                   { ( sem_Decl_11) | True ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                   ( _lhsOgathDataGam,_lhsOgathDeclDataGam,_lhsOgathTySigGam,_lhsOgathTySigVarMp,sem_Decl_11) }) }) }) }) }) }) }))))
                                                                                                                                                                                                                                                                                                                                                                                                                             in  sem_Decl_Class_10)) of
                                                                                                                                                                                                                                                                                                                                                                                                                      { ( sem_Decl_10) | True ->
                                                                                                                                                                                                                                                                                                                                                                                                                      ( _lhsOpatClGam2,sem_Decl_10) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }))))))
                                                                                                                                                                                                                                                                                                                                                                 in  sem_Decl_Class_9)) of
                                                                                                                                                                                                                                                                                                                                                          { ( sem_Decl_9) | True ->
                                                                                                                                                                                                                                                                                                                                                          ( _lhsOpatClGam1,sem_Decl_9) }) }) })))
                                                                                                                                                                                                                                                                                                                                         in  sem_Decl_Class_8)) of
                                                                                                                                                                                                                                                                                                                                  { ( sem_Decl_8) | True ->
                                                                                                                                                                                                                                                                                                                                  ( _lhsOgenerDataInfoL,_lhsOgenerDataInfoMp,_lhsOkiVarMp,_lhsOpolVarMp,sem_Decl_8) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }))))))))))
                                                                                                                                                                                                                                                         in  sem_Decl_Class_7)) of
                                                                                                                                                                                                                                                  { ( sem_Decl_7) | True ->
                                                                                                                                                                                                                                                  ( _lhsOpatKiVarMp,_lhsOpatPolGam,sem_Decl_7) }) }) }) }) }) }) }) }) }) }) }) })))))
                                                                                                                                                                                                                  in  sem_Decl_Class_6)) of
                                                                                                                                                                                                           { ( sem_Decl_6) | True ->
                                                                                                                                                                                                           ( _lhsOpatTyKiGam,_lhsOtyTyVarMp,sem_Decl_6) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) })))))
                                                                                                                                                    in  sem_Decl_Class_5)) of
                                                                                                                                             { ( sem_Decl_5) | True ->
                                                                                                                                             ( _lhsOpatTyGam,sem_Decl_5) }) }) }))))
                                                                                                                           in  sem_Decl_Class_4)) of
                                                                                                                    { ( sem_Decl_4) | True ->
                                                                                                                    ( _lhsOpredSameScopeCounter,sem_Decl_4) }) }))))
                                                                                                   in  sem_Decl_Class_3)) of
                                                                                            { ( sem_Decl_3) | True ->
                                                                                            ( _lhsOgathTyKiSigGam,sem_Decl_3) }) }) }) })))
                                                                      in  sem_Decl_Class_2)) of
                                                               { ( sem_Decl_2) | True ->
                                                               ( _lhsOgUniq,_lhsOgathKiSigGam,_lhsOhasInstDecl,sem_Decl_2) }) }) }) }) }) }) }) }) }) }) }) }))))
                        in  sem_Decl_Class_1)) of
                 { ( sem_Decl_1) | True ->
                 ( _lhsOrange,sem_Decl_1) }) }) }) }) })

sem_Decl_Instance :: Range ->
                     (Maybe (HsName,Bool)) ->
                     InstVariant ->
                     T_TyExpr ->
                     T_Decls ->
                     T_Decl

sem_Decl_Instance hsrange_ mbNmElim_ instVariant_ tyPrExpr_ decls_ | hsrange_ `seq` (mbNmElim_ `seq` (instVariant_ `seq` (tyPrExpr_ `seq` (decls_ `seq` (True))))) =
    (case (decls_) of
     { ( _declsIrange,decls_1) | True ->
         (case (tyPrExpr_) of
          { ( _tyPrExprIrange,tyPrExpr_1) | True ->
              (case (rangeUnions [hsrange_, _tyPrExprIrange
                                                          , _declsIrange ]) of
               { _range | _range `seq` (True) ->
               (case (_range) of
                { _lhsOrange | _lhsOrange `seq` (True) ->
                (case ((let sem_Decl_Instance_1 :: T_Decl_1
                            sem_Decl_Instance_1 =
                                (\ _lhsIgUniq
                                   _lhsIgathKiSigGam ->
                                     _lhsIgUniq `seq`
                                     (_lhsIgathKiSigGam `seq`
                                      ((case (let __cont = _lhsIgUniq in seq __cont ( case nextUnique __cont of { (__cont, lUniq) -> case nextUnique __cont of { (__cont, lUniq3) -> case nextUnique __cont of { (__cont, lUniq4) -> case nextUnique __cont of { (__cont, lUniq5) -> case nextUnique __cont of { (__cont, lUniq6) -> case nextUnique __cont of { (__cont, lUniq7) -> case nextUnique __cont of { (__cont, lUniq_17_polCtx) -> case nextUnique __cont of { (__cont, lUniq_95_altsPrOcc) -> case nextUnique __cont of { (__cont, lUniq_95_extraPrOcc) -> case nextUnique __cont of { (__cont, lUniq_95_fitsIn_dataTy) -> case nextUnique __cont of { (__cont, lUniq_9_prTyFix) -> case nextUnique __cont of { (__cont, lUniq_bind) -> case nextUnique __cont of { (__cont, lUniq_generDeriv1) -> case nextUnique __cont of { (__cont, lUniq_generDeriv2) -> (__cont,lUniq,lUniq3,lUniq4,lUniq5,lUniq6,lUniq7,lUniq_17_polCtx,lUniq_95_altsPrOcc,lUniq_95_extraPrOcc,lUniq_95_fitsIn_dataTy,lUniq_9_prTyFix,lUniq_bind,lUniq_generDeriv1,lUniq_generDeriv2)}}}}}}}}}}}}}} )) of
                                        { __tup58 | __tup58 `seq` (True) ->
                                        (case (__tup58) of
                                         { (_tyPrExprOgUniq,_,_,_,_,_,_,_,_,_,_,_,_,_,_) | _tyPrExprOgUniq `seq` (True) ->
                                         (case (tyPrExpr_1 _tyPrExprOgUniq) of
                                          { ( _tyPrExprIgUniq,tyPrExpr_2) | True ->
                                              (case (_tyPrExprIgUniq) of
                                               { _declsOgUniq | _declsOgUniq `seq` (True) ->
                                               (case (_lhsIgathKiSigGam) of
                                                { _declsOgathKiSigGam | _declsOgathKiSigGam `seq` (True) ->
                                                (case (decls_1 _declsOgUniq _declsOgathKiSigGam) of
                                                 { ( _declsIgUniq,_declsIgathKiSigGam,_declsIhasInstDecl,decls_2) | True ->
                                                     (case (_declsIgUniq) of
                                                      { _lhsOgUniq | _lhsOgUniq `seq` (True) ->
                                                      (case (_declsIgathKiSigGam) of
                                                       { _lhsOgathKiSigGam | _lhsOgathKiSigGam `seq` (True) ->
                                                       (case (True) of
                                                        { _lhsOhasInstDecl | _lhsOhasInstDecl `seq` (True) ->
                                                        (case ((let sem_Decl_Instance_2 :: T_Decl_2
                                                                    sem_Decl_Instance_2 =
                                                                        (\ _lhsIkiGam ->
                                                                             _lhsIkiGam `seq`
                                                                             ((case (_lhsIkiGam) of
                                                                               { _declsOkiGam | _declsOkiGam `seq` (True) ->
                                                                               (case (decls_2 _declsOkiGam) of
                                                                                { ( _declsIgathTyKiSigGam,decls_3) | True ->
                                                                                    (case (_declsIgathTyKiSigGam) of
                                                                                     { _lhsOgathTyKiSigGam | _lhsOgathTyKiSigGam `seq` (True) ->
                                                                                     (case ((let sem_Decl_Instance_3 :: T_Decl_3
                                                                                                 sem_Decl_Instance_3 =
                                                                                                     (\ _lhsIlexLev
                                                                                                        _lhsIpredSameScopeCounter ->
                                                                                                          _lhsIlexLev `seq`
                                                                                                          (_lhsIpredSameScopeCounter `seq`
                                                                                                           ((case (_lhsIpredSameScopeCounter+1) of
                                                                                                             { _lhsOpredSameScopeCounter | _lhsOpredSameScopeCounter `seq` (True) ->
                                                                                                             (case ((let sem_Decl_Instance_4 :: T_Decl_4
                                                                                                                         sem_Decl_Instance_4 =
                                                                                                                             (\ _lhsIpatTyGam
                                                                                                                                _lhsItyKiSigGam ->
                                                                                                                                  _lhsIpatTyGam `seq`
                                                                                                                                  (_lhsItyKiSigGam `seq`
                                                                                                                                   ((case (_lhsIpatTyGam) of
                                                                                                                                     { _lhsOpatTyGam | _lhsOpatTyGam `seq` (True) ->
                                                                                                                                     (case ((let sem_Decl_Instance_5 :: T_Decl_5
                                                                                                                                                 sem_Decl_Instance_5 =
                                                                                                                                                     (\ _lhsIpatTyKiGam
                                                                                                                                                        _lhsItyGam
                                                                                                                                                        _lhsItyTyVarMp ->
                                                                                                                                                          _lhsIpatTyKiGam `seq`
                                                                                                                                                          (_lhsItyGam `seq`
                                                                                                                                                           (_lhsItyTyVarMp `seq`
                                                                                                                                                            ((case (_lhsIpatTyKiGam) of
                                                                                                                                                              { _lhsOpatTyKiGam | _lhsOpatTyKiGam `seq` (True) ->
                                                                                                                                                              (case (_lhsItyTyVarMp) of
                                                                                                                                                               { _declsOtyTyVarMp | _declsOtyTyVarMp `seq` (True) ->
                                                                                                                                                               (case (_lhsItyKiSigGam) of
                                                                                                                                                                { _declsOtyKiSigGam | _declsOtyKiSigGam `seq` (True) ->
                                                                                                                                                                (case (gamPushNew _lhsItyGam) of
                                                                                                                                                                 { _tyPrExprOtyGam | _tyPrExprOtyGam `seq` (True) ->
                                                                                                                                                                 (case (tyPrExpr_2 _tyPrExprOtyGam) of
                                                                                                                                                                  { ( _tyPrExprIty,_tyPrExprItyGam,tyPrExpr_3) | True ->
                                                                                                                                                                      (case (_tyPrExprItyGam) of
                                                                                                                                                                       { _declsOtyGam | _declsOtyGam `seq` (True) ->
                                                                                                                                                                       (case (_lhsIpatTyGam) of
                                                                                                                                                                        { _declsOpatTyGam | _declsOpatTyGam `seq` (True) ->
                                                                                                                                                                        (case (_lhsIlexLev) of
                                                                                                                                                                         { _declsOlexLev | _declsOlexLev `seq` (True) ->
                                                                                                                                                                         (case (0) of
                                                                                                                                                                          { _declsOpredSameScopeCounter | _declsOpredSameScopeCounter `seq` (True) ->
                                                                                                                                                                          (case (decls_3 _declsOlexLev _declsOpredSameScopeCounter) of
                                                                                                                                                                           { ( _declsIpredSameScopeCounter,decls_4) | True ->
                                                                                                                                                                               (case (decls_4 _declsOpatTyGam _declsOtyKiSigGam) of
                                                                                                                                                                                { ( _declsIpatTyGam,decls_5) | True ->
                                                                                                                                                                                    (case (emptyGam) of
                                                                                                                                                                                     { _declsOpatTyKiGam | _declsOpatTyKiGam `seq` (True) ->
                                                                                                                                                                                     (case (decls_5 _declsOpatTyKiGam _declsOtyGam _declsOtyTyVarMp) of
                                                                                                                                                                                      { ( _declsIpatTyKiGam,_declsItyTyVarMp,decls_6) | True ->
                                                                                                                                                                                          (case (_declsItyTyVarMp) of
                                                                                                                                                                                           { _lhsOtyTyVarMp | _lhsOtyTyVarMp `seq` (True) ->
                                                                                                                                                                                           (case ((let sem_Decl_Instance_6 :: T_Decl_6
                                                                                                                                                                                                       sem_Decl_Instance_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_Decl_Instance_7 :: T_Decl_7
                                                                                                                                                                                                                                 sem_Decl_Instance_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 (_lhsItyKiGam) of
                                                                                                                                                                                                                                                   { _tyPrExprOtyKiGam | _tyPrExprOtyKiGam `seq` (True) ->
                                                                                                                                                                                                                                                   (case (_lhsIpolVarMp) of
                                                                                                                                                                                                                                                    { _tyPrExprOpolVarMp | _tyPrExprOpolVarMp `seq` (True) ->
                                                                                                                                                                                                                                                    (case (_lhsIpolGam) of
                                                                                                                                                                                                                                                     { _tyPrExprOpolGam | _tyPrExprOpolGam `seq` (True) ->
                                                                                                                                                                                                                                                     (case (__tup58) of
                                                                                                                                                                                                                                                      { (_,_,_,_,_,_,_,_lUniq_17_polCtx,_,_,_,_,_,_,_) | _lUniq_17_polCtx `seq` (True) ->
                                                                                                                                                                                                                                                      (case (mkPolVar _lUniq_17_polCtx) of
                                                                                                                                                                                                                                                       { _tyPrExprOknPolCtx | _tyPrExprOknPolCtx `seq` (True) ->
                                                                                                                                                                                                                                                       (case (tyPrExpr_3 _tyPrExprOknPolCtx) of
                                                                                                                                                                                                                                                        { ( _tyPrExprIpolVarL,tyPrExpr_4) | True ->
                                                                                                                                                                                                                                                            (case (tyPrExpr_4 _tyPrExprOpolGam _tyPrExprOpolVarMp) of
                                                                                                                                                                                                                                                             { ( _tyPrExprImbStrictness,_tyPrExprIpolVarMp,tyPrExpr_5) | True ->
                                                                                                                                                                                                                                                                 (case (tyPrExpr_5 _tyPrExprOtyKiGam) of
                                                                                                                                                                                                                                                                  { ( _tyPrExprIintlTyKiGam,_tyPrExprItyKiGam,tyPrExpr_6) | True ->
                                                                                                                                                                                                                                                                      (case (_tyPrExprItyKiGam) of
                                                                                                                                                                                                                                                                       { _declsOtyKiGam | _declsOtyKiGam `seq` (True) ->
                                                                                                                                                                                                                                                                       (case (snd $ pscpEnter _lhsIpredSameScopeCounter _lhsIpredScope) of
                                                                                                                                                                                                                                                                        { _predScope | _predScope `seq` (True) ->
                                                                                                                                                                                                                                                                        (case (_predScope) of
                                                                                                                                                                                                                                                                         { _declsOpredScope | _declsOpredScope `seq` (True) ->
                                                                                                                                                                                                                                                                         (case (_tyPrExprIpolVarMp) of
                                                                                                                                                                                                                                                                          { _declsOpolVarMp | _declsOpolVarMp `seq` (True) ->
                                                                                                                                                                                                                                                                          (case (_lhsIpatPolGam) of
                                                                                                                                                                                                                                                                           { _declsOpatPolGam | _declsOpatPolGam `seq` (True) ->
                                                                                                                                                                                                                                                                           (case (_lhsIopts) of
                                                                                                                                                                                                                                                                            { _declsOopts | _declsOopts `seq` (True) ->
                                                                                                                                                                                                                                                                            (case (Nothing) of
                                                                                                                                                                                                                                                                             { _mbKnPolCtx | _mbKnPolCtx `seq` (True) ->
                                                                                                                                                                                                                                                                             (case (_mbKnPolCtx) of
                                                                                                                                                                                                                                                                              { _declsOmbKnPolCtx | _declsOmbKnPolCtx `seq` (True) ->
                                                                                                                                                                                                                                                                              (case (_lhsIkiVarMp) of
                                                                                                                                                                                                                                                                               { _tyPrExprOkiVarMp | _tyPrExprOkiVarMp `seq` (True) ->
                                                                                                                                                                                                                                                                               (case (tyPrExpr_6 _tyPrExprOkiVarMp) of
                                                                                                                                                                                                                                                                                { ( _tyPrExprIgathTyVarPolGam,_tyPrExprIki,_tyPrExprIkiVarMp,_tyPrExprIpol,_tyPrExprItyVarWildMp,tyPrExpr_7) | True ->
                                                                                                                                                                                                                                                                                    (case (_tyPrExprIkiVarMp) of
                                                                                                                                                                                                                                                                                     { _declsOkiVarMp | _declsOkiVarMp `seq` (True) ->
                                                                                                                                                                                                                                                                                     (case (_lhsIgenerDataInfoMp) of
                                                                                                                                                                                                                                                                                      { _declsOgenerDataInfoMp | _declsOgenerDataInfoMp `seq` (True) ->
                                                                                                                                                                                                                                                                                      (case (varFreeSet (                              gamTop _declsIpatTyKiGam) `Set.union` _lhsItyKiGlobFreeTvarS) of
                                                                                                                                                                                                                                                                                       { _declsOtyKiGlobFreeTvarS | _declsOtyKiGlobFreeTvarS `seq` (True) ->
                                                                                                                                                                                                                                                                                       (case (emptyVarMp) of
                                                                                                                                                                                                                                                                                        { _declsOpatKiVarMp | _declsOpatKiVarMp `seq` (True) ->
                                                                                                                                                                                                                                                                                        (case (gamPushNew _lhsIpolGam) of
                                                                                                                                                                                                                                                                                         { _declsOpolGam | _declsOpolGam `seq` (True) ->
                                                                                                                                                                                                                                                                                         (case (decls_6 _declsOpatKiVarMp _declsOpatPolGam _declsOtyKiGam) of
                                                                                                                                                                                                                                                                                          { ( _declsIpatKiVarMp,_declsIpatPolGam,decls_7) | True ->
                                                                                                                                                                                                                                                                                              (case (decls_7 _declsOgenerDataInfoMp _declsOkiVarMp _declsOmbKnPolCtx _declsOopts _declsOpolGam _declsOpolVarMp _declsOpredScope _declsOtyKiGlobFreeTvarS) of
                                                                                                                                                                                                                                                                                               { ( _declsIgenerDataInfoL,_declsIgenerDataInfoMp,_declsIkiVarMp,_declsIpolVarMp,decls_8) | True ->
                                                                                                                                                                                                                                                                                                   (case (_declsIgenerDataInfoL) of
                                                                                                                                                                                                                                                                                                    { _lhsOgenerDataInfoL | _lhsOgenerDataInfoL `seq` (True) ->
                                                                                                                                                                                                                                                                                                    (case (_declsIgenerDataInfoMp) of
                                                                                                                                                                                                                                                                                                     { _lhsOgenerDataInfoMp | _lhsOgenerDataInfoMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                     (case (_declsIkiVarMp) of
                                                                                                                                                                                                                                                                                                      { _lhsOkiVarMp | _lhsOkiVarMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                      (case (_declsIpolVarMp) of
                                                                                                                                                                                                                                                                                                       { _lhsOpolVarMp | _lhsOpolVarMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                       (case ((let sem_Decl_Instance_8 :: T_Decl_8
                                                                                                                                                                                                                                                                                                                   sem_Decl_Instance_8 =
                                                                                                                                                                                                                                                                                                                       (\ _lhsIpatClGam1 ->
                                                                                                                                                                                                                                                                                                                            _lhsIpatClGam1 `seq`
                                                                                                                                                                                                                                                                                                                            ((case (_lhsIpatClGam1) of
                                                                                                                                                                                                                                                                                                                              { _declsOpatClGam1 | _declsOpatClGam1 `seq` (True) ->
                                                                                                                                                                                                                                                                                                                              (case (decls_8 _declsOpatClGam1) of
                                                                                                                                                                                                                                                                                                                               { ( _declsIpatClGam1,decls_9) | True ->
                                                                                                                                                                                                                                                                                                                                   (case (_declsIpatClGam1) of
                                                                                                                                                                                                                                                                                                                                    { _lhsOpatClGam1 | _lhsOpatClGam1 `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                    (case ((let sem_Decl_Instance_9 :: T_Decl_9
                                                                                                                                                                                                                                                                                                                                                sem_Decl_Instance_9 =
                                                                                                                                                                                                                                                                                                                                                    (\ _lhsIfinKiVarMp
                                                                                                                                                                                                                                                                                                                                                       _lhsIfinTyKiGam
                                                                                                                                                                                                                                                                                                                                                       _lhsIpatClGam2
                                                                                                                                                                                                                                                                                                                                                       _lhsItyTyTySigFreeTvarS ->
                                                                                                                                                                                                                                                                                                                                                         _lhsIfinKiVarMp `seq`
                                                                                                                                                                                                                                                                                                                                                         (_lhsIfinTyKiGam `seq`
                                                                                                                                                                                                                                                                                                                                                          (_lhsIpatClGam2 `seq`
                                                                                                                                                                                                                                                                                                                                                           (_lhsItyTyTySigFreeTvarS `seq`
                                                                                                                                                                                                                                                                                                                                                            ((case (_lhsIpatClGam2) of
                                                                                                                                                                                                                                                                                                                                                              { _declsOpatClGam2 | _declsOpatClGam2 `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                              (case (_lhsIfinTyKiGam) of
                                                                                                                                                                                                                                                                                                                                                               { _declsOfinTyKiGam | _declsOfinTyKiGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                               (case (_lhsIfinKiVarMp) of
                                                                                                                                                                                                                                                                                                                                                                { _declsOfinKiVarMp | _declsOfinKiVarMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                (case (varFreeSet (gamTop _tyPrExprItyGam) `Set.union` _lhsItyTyTySigFreeTvarS) of
                                                                                                                                                                                                                                                                                                                                                                 { _declsOtyTyTySigFreeTvarS | _declsOtyTyTySigFreeTvarS `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                 (case (decls_9 _declsOfinKiVarMp _declsOfinTyKiGam _declsOpatClGam2 _declsOtyTyTySigFreeTvarS) of
                                                                                                                                                                                                                                                                                                                                                                  { ( _declsIpatClGam2,decls_10) | True ->
                                                                                                                                                                                                                                                                                                                                                                      (case (_declsIpatClGam2) of
                                                                                                                                                                                                                                                                                                                                                                       { _lhsOpatClGam2 | _lhsOpatClGam2 `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                       (case ((let sem_Decl_Instance_10 :: T_Decl_10
                                                                                                                                                                                                                                                                                                                                                                                   sem_Decl_Instance_10 =
                                                                                                                                                                                                                                                                                                                                                                                       (\ _lhsIclGam
                                                                                                                                                                                                                                                                                                                                                                                          _lhsIgathDataGam ->
                                                                                                                                                                                                                                                                                                                                                                                            _lhsIclGam `seq`
                                                                                                                                                                                                                                                                                                                                                                                            (_lhsIgathDataGam `seq`
                                                                                                                                                                                                                                                                                                                                                                                             ((case (_lhsIgathDataGam) of
                                                                                                                                                                                                                                                                                                                                                                                               { _declsOgathDataGam | _declsOgathDataGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                               (case (_lhsIclGam) of
                                                                                                                                                                                                                                                                                                                                                                                                { _declsOclGam | _declsOclGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                (case (decls_10 _declsOclGam _declsOgathDataGam) of
                                                                                                                                                                                                                                                                                                                                                                                                 { ( _declsIgathDataGam,_declsIgathDeclDataGam,_declsIgathTySigGam,_declsIgathTySigVarMp,decls_11) | True ->
                                                                                                                                                                                                                                                                                                                                                                                                     (case (_declsIgathDataGam) of
                                                                                                                                                                                                                                                                                                                                                                                                      { _lhsOgathDataGam | _lhsOgathDataGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                      (case (_declsIgathDeclDataGam) of
                                                                                                                                                                                                                                                                                                                                                                                                       { _lhsOgathDeclDataGam | _lhsOgathDeclDataGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                       (case (_lhsIclGam) of
                                                                                                                                                                                                                                                                                                                                                                                                        { _tyPrExprOclGam | _tyPrExprOclGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                        (case (tyPrExpr_7 _tyPrExprOclGam) of
                                                                                                                                                                                                                                                                                                                                                                                                         { ( _tyPrExprIevTy,tyPrExpr_8) | True ->
                                                                                                                                                                                                                                                                                                                                                                                                             (case (maybe emptyGam (\(n,_) -> n `gamSingleton` ValGamInfo (tyQuantifyClosed _tyPrExprIevTy)) mbNmElim_) of
                                                                                                                                                                                                                                                                                                                                                                                                              { _lhsOgathTySigGam | _lhsOgathTySigGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                              (case (_declsIgathTySigVarMp) of
                                                                                                                                                                                                                                                                                                                                                                                                               { _lhsOgathTySigVarMp | _lhsOgathTySigVarMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                               (case ((let sem_Decl_Instance_11 :: T_Decl_11
                                                                                                                                                                                                                                                                                                                                                                                                                           sem_Decl_Instance_11 =
                                                                                                                                                                                                                                                                                                                                                                                                                               (\ _lhsIdataGam ->
                                                                                                                                                                                                                                                                                                                                                                                                                                    _lhsIdataGam `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                                    ((case (_lhsIdataGam) of
                                                                                                                                                                                                                                                                                                                                                                                                                                      { _declsOdataGam | _declsOdataGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                      (case (decls_11 _declsOdataGam) of
                                                                                                                                                                                                                                                                                                                                                                                                                                       { ( _declsIchrClassDeclSq,_declsIchrInstDeclSq,_declsIgathClDfGam,decls_12) | True ->
                                                                                                                                                                                                                                                                                                                                                                                                                                           (case (_declsIchrClassDeclSq) of
                                                                                                                                                                                                                                                                                                                                                                                                                                            { _lhsOchrClassDeclSq | _lhsOchrClassDeclSq `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                            (case (__tup58) of
                                                                                                                                                                                                                                                                                                                                                                                                                                             { (_,_,_,_,_,_,_,_,_,_,_,_lUniq_9_prTyFix,_,_,_) | _lUniq_9_prTyFix `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                             (case (__tup58) of
                                                                                                                                                                                                                                                                                                                                                                                                                                              { (_,_lUniq,_,_,_,_,_,_,_,_,_,_,_,_,_) | _lUniq `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                              (case (mkPrIdCHR _lUniq) of
                                                                                                                                                                                                                                                                                                                                                                                                                                               { _instId | _instId `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                               (case (maybe (poiHNm _instId,True) id mbNmElim_) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                { __tup54 | __tup54 `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                (case (__tup54) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                 { (_,_inclForElim) | _inclForElim `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                 (case (__tup54) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                  { (_dictNm,_) | _dictNm `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                  (case (tyFixTyVars _lUniq_9_prTyFix $ tyQuantifyRank [2..] $ tyCanonic (emptyTyBetaRedEnv' emptyFE)  _tyPrExprIty) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                   { __tup51 | __tup51 `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                   (case (__tup51) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                    { (_prTyFix,_,_,_) | _prTyFix `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                    (case (case instVariant_ of
                                                                                                                                                                                                                                                                                                                                                                                                                                                             InstDeriving instFrom
                                                                                                                                                                                                                                                                                                                                                                                                                                                               -> ( cx ++ cxDt, hd', predTyCon, dataTy, tgi, dgi, errs1 ++ errs2
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  , derivTyArgs, tyNm, derivArity, derivTruncTailArity
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  )
                                                                                                                                                                                                                                                                                                                                                                                                                                                               where (cx,hd@(Ty_Pred (Pred_Class predTy)))
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   = appUnArr _prTyFix
                                                                                                                                                                                                                                                                                                                                                                                                                                                                     (predTyCon,dataTyL)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   = appUnApp predTy
                                                                                                                                                                                                                                                                                                                                                                                                                                                                     dataTy        = last' (panic "InferClass.Decl.Instance.{metaPrTyVarMp,..}.dataTyL") dataTyL
                                                                                                                                                                                                                                                                                                                                                                                                                                                                     (dataTyCon,dataTyArgs)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   = appUnApp dataTy
                                                                                                                                                                                                                                                                                                                                                                                                                                                                     tyNm          = tyConNm dataTyCon
                                                                                                                                                                                                                                                                                                                                                                                                                                                                     clNm          = tyConNm predTyCon
                                                                                                                                                                                                                                                                                                                                                                                                                                                                     (tgi,tkgi,dgi,ctkgi,errs1)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   = derivGetDataTyInfo clNm tyNm _lhsItyGam _lhsItyKiGam _lhsIdataGam
                                                                                                                                                                                                                                                                                                                                                                                                                                                                     derivTyArgs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                       | dgiIsRec dgi = assocLElts $ snd $ tyRecExts dataTy
                                                                                                                                                                                                                                                                                                                                                                                                                                                                       | otherwise    = dataTyArgs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                     dataTyKi      = _declsIkiVarMp `varUpd` tkgiKi tkgi
                                                                                                                                                                                                                                                                                                                                                                                                                                                                     classTyKi     = _declsIkiVarMp `varUpd` tkgiKi ctkgi
                                                                                                                                                                                                                                                                                                                                                                                                                                                                     lastArgArity  = maybe 0 (\(_,l) -> length $ appUnArrArgs l) $ initlast $ appUnArrArgs classTyKi
                                                                                                                                                                                                                                                                                                                                                                                                                                                                     derivArity    = maybe 0 (`min` lastArgArity) $ dgiMbGenerInfo dgi
                                                                                                                                                                                                                                                                                                                                                                                                                                                                     dataTyArgs'   = take (length dataTyArgs - derivArity) dataTyArgs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                     (hd',derivTruncTailArity)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   = case instFrom of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       InstDerivingFrom_Datatype   -> (mkTyPr $ Pred_Class $ appTopApp [predTyCon, appTopApp (dataTyCon : dataTyArgs')], derivArity)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       InstDerivingFrom_Standalone -> (hd                                                                              , 0         )
                                                                                                                                                                                                                                                                                                                                                                                                                                                                     (cxDt,_,errs2)= case instFrom of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       InstDerivingFrom_Datatype
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         -> maybe ([],_lUniq,[rngLift _range Err_MalformedTy "kind" "automatic instance derivation" dataTyKi])
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (\(t,u) -> (t,u,[]))
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            $ mkDerivPredContext _lUniq derivArity predTyCon (appUnArrArgs dataTyKi) dataTyArgs'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       InstDerivingFrom_Standalone
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         -> ([],_lUniq,[])
                                                                                                                                                                                                                                                                                                                                                                                                                                                             _ -> ( cx,hd,Ty_Any,Ty_Any,emptyTGI,emptyDGI,[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  , [], hsnUnknown, 0, 0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  )
                                                                                                                                                                                                                                                                                                                                                                                                                                                               where (cx,hd) = appUnArr _prTyFix) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                     { __tup52 | __tup52 `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                     (case (__tup52) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                      { (_,_hdPrTyFix,_,_,_,_,_,_,_,_,_) | _hdPrTyFix `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                      (case (__tup52) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                       { (_ctxtPrTyFixL,_,_,_,_,_,_,_,_,_,_) | _ctxtPrTyFixL `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                       (case (__tup51) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                        { (_,_,_unfixPrTyVarMp,_) | _unfixPrTyVarMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                        (case (let cx = _unfixPrTyVarMp `varUpd` _ctxtPrTyFixL
                                                                                                                                                                                                                                                                                                                                                                                                                                                                   hd = _unfixPrTyVarMp `varUpd` _hdPrTyFix
                                                                                                                                                                                                                                                                                                                                                                                                                                                                   hdPr = tyPred hd
                                                                                                                                                                                                                                                                                                                                                                                                                                                               in  ( map tyPred cx
                                                                                                                                                                                                                                                                                                                                                                                                                                                                   , hdPr
                                                                                                                                                                                                                                                                                                                                                                                                                                                                   , RedHow_ByInstance _dictNm hdPr _lhsIpredScope
                                                                                                                                                                                                                                                                                                                                                                                                                                                                   , _lhsIpredScope
                                                                                                                                                                                                                                                                                                                                                                                                                                                                   )) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                         { _chrInstDecl | _chrInstDecl `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                         (case (if _inclForElim then Seq.singleton _chrInstDecl else Seq.empty) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                          { _lhsOchrInstDeclSq | _lhsOchrInstDeclSq `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                          (case (_declsIgathClDfGam) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                           { _lhsOgathClDfGam | _lhsOgathClDfGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                           (case ((let sem_Decl_Instance_12 :: T_Decl_12
                                                                                                                                                                                                                                                                                                                                                                                                                                                                       sem_Decl_Instance_12 =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                           (\ _lhsIpatTyVarMp
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              _lhsIpatValGam
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              _lhsItvKiVarMp
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              _lhsItySigGam
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              _lhsItySigVarMp ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _lhsIpatTyVarMp `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (_lhsIpatValGam `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 (_lhsItvKiVarMp `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (_lhsItySigGam `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   (_lhsItySigVarMp `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ((case (_lhsIpatTyVarMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      { _lhsOpatTyVarMp | _lhsOpatTyVarMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      (case (tyPredMatchNmArgs _hdPrTyFix) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       { __tup53 | __tup53 `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       (case (__tup53) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        { (_instClsNm,_) | _instClsNm `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (case (hsnClass2Dict _instClsNm) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         { _dataDictNm | _dataDictNm `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         (case (__tup53) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          { (_,_instArgTyL) | _instArgTyL `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          (case (appConApp _dataDictNm _instArgTyL) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           { _dataDictTy | _dataDictTy `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           (case (map tyPred _ctxtPrTyFixL) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            { _ctxtPrFixL | _ctxtPrFixL `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (case (ValGamInfo
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     (tyQuantifyClosed $ varUpd _unfixPrTyVarMp $
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       (case instVariant_ of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         InstDefault -> [_dataDictTy]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         _           -> map pred2DataTy _ctxtPrFixL
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       ) `appArr` _dataDictTy)) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             { _vgi | _vgi `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             (case (gamTopUpdate (const _vgi) _dictNm _lhsIpatValGam) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              { _lhsOpatValGam | _lhsOpatValGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              (case ((let sem_Decl_Instance_13 :: T_Decl_13
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          sem_Decl_Instance_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 (_lhsIvalGam) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           { _declsOvalGam | _declsOvalGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           (case (_lhsItySigVarMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            { _declsOtySigVarMp | _declsOtySigVarMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (case (__tup51) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             { (_,_fixPrTyVarMp,_,_) | _fixPrTyVarMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             (case ((_fixPrTyVarMp `varUpd`) $ tyQuantifyRank' (\k -> isJust $ varmpTyLookup k _fixPrTyVarMp) [2..] $ appUnArrRes _tyPrExprIevTy) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              { _recTy | _recTy `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              (case (snd $ tyRecExts _recTy) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               { _recTyExts | _recTyExts `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               (case (assocLToGam $ assocLMapElt ValGamInfo _recTyExts) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                { _tySigGam | _tySigGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (case (_tySigGam) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 { _declsOtySigGam | _declsOtySigGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 (case (_lhsItvKiVarMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  { _declsOtvKiVarMp | _declsOtvKiVarMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (case (_lhsIclDfGam) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   { _declsOclDfGam | _declsOclDfGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   (case (_lhsIchrStore) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    { _declsOchrStore | _declsOchrStore `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (case (varFreeSet (gamTop _tyPrExprItyGam) `Set.union` _lhsItyTyGlobFreeTvarS) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     { _declsOtyTyGlobFreeTvarS | _declsOtyTyGlobFreeTvarS `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     (case (_fixPrTyVarMp `varUpd` _lhsItyVarMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      { _declsOpatTyVarMp | _declsOpatTyVarMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      (case (gamPushNew _lhsIpatValGam) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       { _declsOpatValGam | _declsOpatValGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       (case (decls_12 _declsOpatTyVarMp _declsOpatValGam _declsOtvKiVarMp _declsOtySigGam _declsOtySigVarMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        { ( _declsIpatTyVarMp,_declsIpatValGam,decls_13) | True ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (case (varFreeSet (gamTop _declsIpatValGam) `Set.union` _lhsIvalTyGlobFreeTvarS) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             { _declsOvalTyGlobFreeTvarS | _declsOvalTyGlobFreeTvarS `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             (case (_declsIpatTyVarMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              { _declsOtyVarMp | _declsOtyVarMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              (case (decls_13 _declsOchrStore _declsOclDfGam _declsOtyTyGlobFreeTvarS _declsOtyVarMp _declsOvalGam _declsOvalTyGlobFreeTvarS) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               { ( _declsIgathCnstrMp,_declsIgathRangeMp,_declsIintlTyKiGam,_declsInoLetQuantTyVarIdS,_declsIscopeGam,_declsItyVarMp,decls_14) | True ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   (case (_declsIgathRangeMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    { _lhsOgathRangeMp | _lhsOgathRangeMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (case (_tyPrExprIintlTyKiGam `gamUnion` _declsIintlTyKiGam) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     { _lhsOintlTyKiGam | _lhsOintlTyKiGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     (case (_declsInoLetQuantTyVarIdS) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      { _lhsOnoLetQuantTyVarIdS | _lhsOnoLetQuantTyVarIdS `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      (case (_declsIscopeGam) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       { _lhsOscopeGam | _lhsOscopeGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       (case (_declsItyVarMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        { _lhsOtyVarMp | _lhsOtyVarMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (case ((let sem_Decl_Instance_14 :: T_Decl_14
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    sem_Decl_Instance_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
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         { _declsOsysfEnv | _declsOsysfEnv `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         (case (_lhsIrangeMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          { _declsOrangeMp | _declsOrangeMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          (case (_lhsIfinValGam) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           { _declsOfinValGam | _declsOfinValGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           (case (_lhsIfinTyVarMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            { _declsOfinTyVarMp | _declsOfinTyVarMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (case (_lhsIopts) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             { _tyPrExprOopts | _tyPrExprOopts `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             (case (__tup58) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              { (_,_,_,_,_,_,_,_,_,_,_,_,_,_,_lUniq_generDeriv2) | _lUniq_generDeriv2 `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              (case (__tup58) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               { (_,_,_,_,_,_,_,_,_,_,_,_,_,_lUniq_generDeriv1,_) | _lUniq_generDeriv1 `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               (case (__tup58) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                { (_,_,_,_,_,_,_,_,_,_,_lUniq_95_fitsIn_dataTy,_,_,_,_) | _lUniq_95_fitsIn_dataTy `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (case (__tup58) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 { (_,_,_,_,_,_,_,_,_,_lUniq_95_extraPrOcc,_,_,_,_,_) | _lUniq_95_extraPrOcc `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 (case (__tup58) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  { (_,_,_,_,_,_,_,_,_lUniq_95_altsPrOcc,_,_,_,_,_,_) | _lUniq_95_altsPrOcc `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (case (__tup58) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   { (_,_,_,_,_,_,_lUniq7,_,_,_,_,_,_,_,_) | _lUniq7 `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   (case (__tup58) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    { (_,_,_,_,_,_lUniq6,_,_,_,_,_,_,_,_,_) | _lUniq6 `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (case (__tup58) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     { (_,_,_,_,_lUniq5,_,_,_,_,_,_,_,_,_,_) | _lUniq5 `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     (case (__tup58) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      { (_,_,_,_lUniq4,_,_,_,_,_,_,_,_,_,_,_) | _lUniq4 `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      (case (__tup58) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       { (_,_,_lUniq3,_,_,_,_,_,_,_,_,_,_,_,_) | _lUniq3 `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       (case (defaultFIEnv
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  { feEHCOpts = _lhsIopts
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  , fePredScope = _lhsIpredScope
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  , feTyGam = _lhsItyGam
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  , fePolGam = _lhsIpolGam
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  , feRange = _range
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        { _fe | _fe `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (case (_instClsNm == (ehbnClassIx $ ehcOptBuiltinNames _lhsIopts)) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         { _derivIsIx | _derivIsIx `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         (case (_instClsNm == (ehbnClassBounded $ ehcOptBuiltinNames _lhsIopts)) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          { _derivIsBounded | _derivIsBounded `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          (case (_instClsNm == (ehbnClassEnum $ ehcOptBuiltinNames _lhsIopts)) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           { _derivIsEnum | _derivIsEnum `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           (case (__tup52) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            { (_,_,_,_,_derivDataTGI,_,_,_,_,_,_) | _derivDataTGI `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (case (dataGamTagsOfTy (tgiTy _derivDataTGI) _lhsIdataGam) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             { _mbDerivDataCTags | _mbDerivDataCTags `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             (case (isJust _mbDerivDataCTags
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    && (length (fromJust _mbDerivDataCTags) > 1)) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              { _derivDataHasGt1Constrs | _derivDataHasGt1Constrs `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              (case (isJust _mbDerivDataCTags
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     && (any (\t -> ctagArity t > 0) $ fromJust _mbDerivDataCTags)) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               { _derivDataHasFlds | _derivDataHasFlds `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               (case (mkDerivClsMp _fe _lhsIvalGam _lhsIdataGam) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                { _derivMp | _derivMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (case (Map.lookup _instClsNm _derivMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 { _mbDerivDCL | _mbDerivDCL `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 (case (__tup52) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  { (_,_,_,_,_,_derivDataDGI,_,_,_,_,_) | _derivDataDGI `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (case (isJust _mbDerivDCL && not (dgiIsRec _derivDataDGI)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         && (not ((_derivIsEnum || _derivIsIx) && _derivDataHasFlds))
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         && (not (_derivIsBounded && _derivDataHasGt1Constrs && _derivDataHasFlds))) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   { _derivCanBeDoneBuiltin | _derivCanBeDoneBuiltin `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   (case (case gamLookup _instClsNm _lhsIclGam of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Nothing    ->  (emptyCLGI,[rngLift _range mkErr_NamesNotIntrod "class" [_instClsNm]])
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Just clgi  ->  (clgi,[])) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    { __tup56 | __tup56 `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (case (__tup56) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     { (_clgi,_) | _clgi `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     (case (__tup52) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      { (_,_,_,_,_,_,_,_,_,_,_derivTruncTailArity) | _derivTruncTailArity `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      (case (__tup52) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       { (_,_,_,_,_,_,_,_,_,_derivArity,_) | _derivArity `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       (case (__tup52) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        { (_,_,_,_,_,_,_,_,_derivDataTyNm,_,_) | _derivDataTyNm `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (case (__tup52) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         { (_,_,_,_,_,_,_,_derivDataTyArgs,_,_,_) | _derivDataTyArgs `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         (case (case instVariant_ of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  InstDeriving _ | not _derivCanBeDoneBuiltin && not (null generDerivFlds)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -> [ ( fldNm, dfltvalNm
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         ,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           repTy `app1Arr` vgiTy (fromJust mbFSig)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         , vgiTy (fromJust mbDSig)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         )
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       | ((fldNm,dfltvalNm),u) <- zip generDerivFlds (mkNewLevUIDL (length generDerivFlds) _lUniq_generDeriv1)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       , let mbFSig = valGamLookup fldNm     _tySigGam  , isJust mbFSig
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       , let mbDSig = valGamLookup dfltvalNm _lhsIvalGam, isJust mbDSig
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       , let repTy  = appTopApp (  [appCon repTyNm]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ++ take (dataArity - _derivTruncTailArity) _derivDataTyArgs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ++ [mkTyVar u]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                )
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       ]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    where generDerivFlds = clgiGenerDerivableL _clgi
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          dataArity = length _derivDataTyArgs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          repTyNm | dgiIsRec _derivDataDGI = ehcOptBuiltin _lhsIopts ehbnGenerTupleRepresentableN _derivArity dataArity
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | otherwise              = hsnNm2GenerReprSyn _derivArity _derivDataTyNm
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  _ -> []) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          { _generForFitsInL | _generForFitsInL `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          (case (let (tfldL,tdfltL) = unzip [ (tfld,tdflt) | (_,_,tfld,tdflt) <- _generForFitsInL ]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 in  fitsInL' strongFIOpts (_fe {fePredScope = _predScope}) _lUniq_generDeriv2 _declsItyVarMp tdfltL tfldL) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           { __tup42 | __tup42 `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           (case (__tup42) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            { (_,_foGenerDeriv) | _foGenerDeriv `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (case (varmpSelectMetaLev [0] $
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   foVarMp _foGenerDeriv `varUpd`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   _declsItyVarMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             { _tyVarMpDeclsL0 | _tyVarMpDeclsL0 `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             (case (_tyVarMpDeclsL0) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              { _tyVarMpDeclsL01 | _tyVarMpDeclsL01 `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              (case (mkDoPredAmbigSplitForSimplify
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         (mkDoValGamQuantify
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             _lhsIfinTyKiGam _lhsItvKiVarMp
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             (setSubst _tyVarMpDeclsL0 _declsInoLetQuantTyVarIdS)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             (gamTop _declsIpatValGam))
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         _tyVarMpDeclsL01) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               { _doPredAmbigSplitForSimplify | _doPredAmbigSplitForSimplify `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               (case (defaultFIEnv
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          { feTyGam = _lhsItyGam
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          , fePolGam = _lhsIpolGam
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          , feRange = _range
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          }) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                { _fe2 | _fe2 `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (case (not $ null _generForFitsInL) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 { _derivCanBeDoneGeneric | _derivCanBeDoneGeneric `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 (case (__tup52) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  { (_,_,_,_derivHdDataTy,_,_,_,_,_,_,_) | _derivHdDataTy `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (case (_lhsIvalTyGlobFreeTvarS) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   { _tyPrExprOvalTyGlobFreeTvarS | _tyPrExprOvalTyGlobFreeTvarS `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   (case (_lhsItyTyTySigFreeTvarS) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    { _tyPrExprOtyTyTySigFreeTvarS | _tyPrExprOtyTyTySigFreeTvarS `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (case (_lhsItyTyGlobFreeTvarS) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     { _tyPrExprOtyTyGlobFreeTvarS | _tyPrExprOtyTyGlobFreeTvarS `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     (case (_lhsItyKiGlobFreeTvarS) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      { _tyPrExprOtyKiGlobFreeTvarS | _tyPrExprOtyKiGlobFreeTvarS `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      (case (_lhsItr) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       { _tyPrExprOtr | _tyPrExprOtr `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       (case (_lhsIsysfEnv) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        { _tyPrExprOsysfEnv | _tyPrExprOsysfEnv `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (case (_lhsImoduleNm) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         { _tyPrExprOmoduleNm | _tyPrExprOmoduleNm `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         (case (_lhsIkiGam) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          { _tyPrExprOkiGam | _tyPrExprOkiGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          (case (_lhsIfinTyVarMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           { _tyPrExprOfinTyVarMp | _tyPrExprOfinTyVarMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           (case (_lhsIfinTyKiGam) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            { _tyPrExprOfinTyKiGam | _tyPrExprOfinTyKiGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (case (_lhsIfinKiVarMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             { _tyPrExprOfinKiVarMp | _tyPrExprOfinKiVarMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             (case (tyPrExpr_8 _tyPrExprOfinKiVarMp _tyPrExprOfinTyKiGam _tyPrExprOfinTyVarMp _tyPrExprOkiGam _tyPrExprOmoduleNm _tyPrExprOopts _tyPrExprOsysfEnv _tyPrExprOtr _tyPrExprOtyKiGlobFreeTvarS _tyPrExprOtyTyGlobFreeTvarS _tyPrExprOtyTyTySigFreeTvarS _tyPrExprOvalTyGlobFreeTvarS) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              { ( _tyPrExprIallErrSq,_tyPrExprIappArgPPL,_tyPrExprIappFunNm,_tyPrExprIappFunPP,_tyPrExprIclMissNmS,_tyPrExprIclNmS,_tyPrExprIerrSq,_tyPrExprIgathMentrelFilterMp,_tyPrExprIpp,_tyPrExprIppAST,_tyPrExprItrpp,_tyPrExprItyWildL) | True ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (case (let mke m = [rngLift _range Err_NoDerivForData _derivHdDataTy _instClsNm m]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         in  case ( _derivCanBeDoneBuiltin
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  , instVariant_
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  , _mbDerivDataCTags
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  )
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               (False,InstDeriving _,_)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | _derivCanBeDoneGeneric -> []
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | otherwise              -> [rngLift _range Err_NoDerivFor _tyPrExprIpp]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               (True,InstDeriving _,Just [])   -> mke "has no constructors"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               (True,InstDeriving _,Just _)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | (_derivIsEnum || _derivIsIx) && _derivDataHasFlds
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          -> mke "has a constructor with >0 fields"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               (True,InstDeriving _,Just ctags@(_:_:_))
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | _derivIsBounded && _derivDataHasGt1Constrs && _derivDataHasFlds
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          -> mke "has >1 constructors, of which >0 with fields"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               _                          -> []) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   { _derivErrs | _derivErrs `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   (case (let  t      =  clgiRuleTy _clgi
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               st     =  mkNewTyVarL (length $ appUnArrArgs $ tyQuant t) _lUniq4 `appArr` _hdPrTyFix
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               fo     =  fitsIn predFIOpts _fe2 _lUniq3 (emptyVarMp :: VarMp) t st
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          in   appUnArrArgs $ foVarMp fo `varUpd` foTy fo) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    { _supPrTyL | _supPrTyL `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (case (mkInstanceBuildNms _dictNm) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     { __tup55 | __tup55 `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     (case (__tup55) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      { (_,_dictSelfNm) | _dictSelfNm `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      (case (__tup55) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       { (_dictBuildNm,_) | _dictBuildNm `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       (case (__tup52) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        { (_,_,_derivHdPrTyCon,_,_,_,_,_,_,_,_) | _derivHdPrTyCon `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (case (emptyFI {fiEnv = _fe} :: FIIn) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         { _chrFIIn | _chrFIIn `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         (case (let (u:us) = mkNewUIDL (lc + ls + 1) _lUniq6
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (usc,uss) = splitAt lc us
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    lc = length _ctxtPrFixL
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ls = length _supPrTyL
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    mka p u = rngLift _range mkAssumeConstraint p u _predScope
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    mkp p u = rngLift _range mkProveConstraint  p u _predScope
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (dNm,toAssume,toProve)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       = case instVariant_ of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           InstDefault -> ( _dictSelfNm
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          , emptyCnstrMp
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          , emptyCnstrMp
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          )
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           _           -> ( _dictBuildNm
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          , cnstrMpFromList $ zipWith mka _ctxtPrFixL            usc
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          , cnstrMpFromList $ zipWith mkp (map tyPred _supPrTyL) uss
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          )
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                in  ( toAssume, toProve
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    , cnstrMpFromList [rngLift _range mkAssumeConstraint' (tyPred _hdPrTyFix) u dNm _predScope]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    , usc, map mkHNm usc
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    , uss, map mkHNm uss
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    , u, dNm
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    )) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          { __tup43 | __tup43 `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          (case (__tup43) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           { (_,_chrSuperProveCnstrMp,_,_,_,_,_,_,_) | _chrSuperProveCnstrMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           (case (__tup43) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            { (_chrCtxtAssumeCnstrMp,_,_,_,_,_,_,_,_) | _chrCtxtAssumeCnstrMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (case (cnstrMpUnions [_chrCtxtAssumeCnstrMp,_chrSuperProveCnstrMp]) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             { _toProveSuperCnstrMp | _toProveSuperCnstrMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             (case (_chrFIIn {fiVarMp = _tyVarMpDeclsL0}) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              { _chrProveFIIn | _chrProveFIIn `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              (case (ehcOptTrace _lhsIopts "Decl.Instance.simplify2" $
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     simplify [SimplifyHow_Canonicalize] (_chrProveFIIn {fiUniq = _lUniq5}) _lhsIchrStore _lhsIclDfGam (heurScopedEHC _chrProveFIIn) ((,) []) Map.empty _toProveSuperCnstrMp emptySimplifyResult) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               { __tup47 | __tup47 `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               (case (__tup47) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                { (_,_chrSolveSuperRemCnstrMp,_,_,_,_,_,_,_,_,_) | _chrSolveSuperRemCnstrMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (case (__tup42) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 { (_foGenerDerivL,_) | _foGenerDerivL `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 (case (cnstrMpUnions $ map foGathCnstrMp _foGenerDerivL) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  { _generCnstrMp | _generCnstrMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (case (case instVariant_ of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           InstDeriving _
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | _derivCanBeDoneBuiltin
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               -> ( gathPredLToProveCnstrMp $ foVarMp foDt `varUpd` concat (extraPrOcc : altsPrOcc)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  , altsPrOcc, extraPrOcc
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  , fromJust _mbDerivDCL
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  )
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | _derivCanBeDoneGeneric
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               -> ( cnstrMpUnions [
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       _tyVarMpDeclsL0 `varUpd` _generCnstrMp
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  , [], []
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  , emptyDerivCls
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  )
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | otherwise
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               -> (emptyCnstrMp,[],[],emptyDerivCls)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             where ([dataTy],dataAltTy) = appUnArr $ dgiDataTy _derivDataDGI
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   alts = tyRecExts2 dataAltTy
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   altsPrOcc
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        = [ [ rngLift _range mkPredOccRng (Pred_Class (appTopApp [_derivHdPrTyCon,t])) (mkPrIdCHR u2) _predScope
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | ((_,t),u2) <- zip a1 (mkNewUIDL (length a1) u1)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | ((_,a1),u1) <- zip alts (mkNewLevUIDL (length alts) _lUniq_95_altsPrOcc)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   extraPrOcc
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        = [ rngLift _range mkPredOccRng (Pred_Class (dccMkTy cx)) (mkPrIdCHR u) _predScope
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | (cx,u) <- zip cxl (mkNewUIDL (length cxl) _lUniq_95_extraPrOcc)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        where cxl = maybe [] dclExtraCtxt _mbDerivDCL
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   foDt = fitsIn unifyFIOpts _fe _lUniq_95_fitsIn_dataTy (emptyVarMp :: VarMp) dataTy _derivHdDataTy
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           _ -> (_tyVarMpDeclsL0         `varUpd` _declsIgathCnstrMp,[],[],emptyDerivCls)) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   { __tup44 | __tup44 `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   (case (__tup44) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    { (_toProveGathCnstrMp,_,_,_) | _toProveGathCnstrMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (case (__tup43) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     { (_,_,_chrInstAssumeCnstrMp,_,_,_,_,_,_) | _chrInstAssumeCnstrMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     (case (cnstrMpUnions [_chrInstAssumeCnstrMp, _chrCtxtAssumeCnstrMp, _toProveGathCnstrMp]) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      { _toProveDeclsCnstrMp | _toProveDeclsCnstrMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      (case (ehcOptTrace _lhsIopts "Decl.Instance.simplify1" $
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             simplify [SimplifyHow_Canonicalize] (_chrProveFIIn {fiUniq = _lUniq7}) _lhsIchrStore _lhsIclDfGam (heurScopedEHC _chrProveFIIn) _doPredAmbigSplitForSimplify Map.empty _toProveDeclsCnstrMp emptySimplifyResult) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       { __tup45 | __tup45 `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       (case (__tup45) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        { (_,_chrSolveDeclsRemCnstrMp,_,_,_,_,_,_,_,_,_) | _chrSolveDeclsRemCnstrMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (case (cnstrMpUnions [_chrSolveDeclsRemCnstrMp,_chrSolveSuperRemCnstrMp]) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         { _toAssumeNeverCnstrMp | _toAssumeNeverCnstrMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         (case (__tup47) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          { (_,_,_cannotResSuperCnstrMp,_,_,_,_,_,_,_,_) | _cannotResSuperCnstrMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          (case (__tup45) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           { (_,_,_cannotResDeclsCnstrMp,_,_,_,_,_,_,_,_) | _cannotResDeclsCnstrMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           (case (cnstrMpUnions [_toAssumeNeverCnstrMp,_cannotResDeclsCnstrMp,_cannotResSuperCnstrMp]) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            { _cannotProveCnstrMp | _cannotProveCnstrMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (case (mkPrvErr _lhsIrangeMp _range _cannotProveCnstrMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             { _predNotPrfErrs | _predNotPrfErrs `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             (case (let ns = gamKeys (gamTop _declsIpatValGam) \\ gamKeys _tySigGam
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    in  if null ns
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        then []
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        else [rngLift _range Err_ValWithoutSig ns]) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              { _valNoSigErrs | _valNoSigErrs `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              (case (__tup56) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               { (_,_clgiNmErrs) | _clgiNmErrs `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               (case (__tup52) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                { (_,_,_,_,_,_,_cxSplitErrs,_,_,_,_) | _cxSplitErrs `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (case (__tup47) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 { (_,_,_,_,_chrSolveSuperErrs,_,_,_,_,_,_) | _chrSolveSuperErrs `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 (case (__tup45) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  { (_,_,_,_,_chrSolveDeclsErrs,_,_,_,_,_,_) | _chrSolveDeclsErrs `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (case (Seq.firstNotEmpty
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           [ Seq.fromList _clgiNmErrs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           , Seq.unions [
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          case instVariant_ of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            InstDeriving InstDerivingFrom_Datatype
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              -> Seq.empty
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ -> _tyPrExprIerrSq
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        , Seq.fromList _valNoSigErrs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           , Seq.unions $ map Seq.fromList [_cxSplitErrs, _derivErrs]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           , foErrSq _foGenerDeriv
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           , Seq.unions $ map Seq.fromList [_predNotPrfErrs, _chrSolveSuperErrs, _chrSolveDeclsErrs]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           ]) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   { _lErrSq | _lErrSq `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   (case (_lhsItr) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    { _declsOtr | _declsOtr `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (case (_lhsImoduleNm) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     { _declsOmoduleNm | _declsOmoduleNm `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     (case (_lhsIkiSigGam) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      { _declsOkiSigGam | _declsOkiSigGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      (case (_lhsIisStrict) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       { _declsOisStrict | _declsOisStrict `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       (case (__tup45) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        { (_,_,_,_,_,_,_,_,_,_chrSolveDeclsScopeBindMp,_) | _chrSolveDeclsScopeBindMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (case (_chrSolveDeclsScopeBindMp `predScopeToBindMapUnion` _lhsIchrScopeBindMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         { _chrScopeBindMp | _chrScopeBindMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         (case (_chrScopeBindMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          { _declsOchrScopeBindMp | _declsOchrScopeBindMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          (case (__tup45) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           { (_,_,_,_,_,_,_,_,_chrSolveDeclsEvidBindMp,_,_) | _chrSolveDeclsEvidBindMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           (case (_chrSolveDeclsEvidBindMp `evidKeyToBindMapUnion` _lhsIchrEvidBindMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            { _chrEvidBindMp | _chrEvidBindMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (case (_chrEvidBindMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             { _declsOchrEvidBindMp | _declsOchrEvidBindMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             (case (cSubstApp _lhsIcSubst
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    $ evidKeyBindMpToCSubst _chrEvidBindMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              { _cSubstDecls | _cSubstDecls `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              (case (_cSubstDecls) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               { _declsOcSubst | _declsOcSubst `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               (case (decls_14 _declsOcSubst _declsOchrEvidBindMp _declsOchrScopeBindMp _declsOfinTyVarMp _declsOfinValGam _declsOisStrict _declsOkiSigGam _declsOmoduleNm _declsOrangeMp _declsOsysfEnv _declsOtr) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                { ( _declsIallErrSq,_declsIbangEvalL,_declsIcSubst,_declsIerrSq,_declsIffeCBindL,_declsIffiCBindL,_declsIgathHiddenExports,_declsIgathLamMp,_declsIgathMentrelFilterMp,_declsIgathTvKiVarMp,_declsIorphanS,_declsIpp,_declsIppAST,_declsItrpp,_declsItyCBindL,_declsIvalCBindL) | True ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (case (Seq.unions [_lErrSq, _declsIallErrSq]) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     { _lhsOallErrSq | _lhsOallErrSq `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     (case (_declsIbangEvalL) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      { _lhsObangEvalL | _lhsObangEvalL `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      (case (__tup58) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       { (_,_,_,_,_,_,_,_,_,_,_,_,_lUniq_bind,_,_) | _lUniq_bind `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       (case ((emptyRCEEnv _lhsIopts) { rceValGam = _lhsIvalGam, rceDataGam = _lhsIdataGam, rceTyVarMp = _lhsIfinTyVarMp }) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        { _rceEnv | _rceEnv `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (case (maybe (appDbg "EH.FinalInfo.Decl.Instance.finalTy") vgiTy $ valGamLookup _dictNm        _lhsIfinValGam) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         { _finalTy | _finalTy `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         (case (mkClassCTag _dataDictNm (length _recTyExts)) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          { _dataDictTag | _dataDictTag `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          (case (if ehcCfgClassViaRec _lhsIopts then CTagRec else _dataDictTag) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           { _dictTag | _dictTag `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           (case (__tup44) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            { (_,_,_derivExtraPrOcc,_) | _derivExtraPrOcc `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (case (__tup44) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             { (_,_derivAltsPrOcc,_,_) | _derivAltsPrOcc `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             (case (mkInstanceDerivingFldBind _lhsIopts _rceEnv _lhsIdataGam _lUniq _derivDataDGI _derivHdDataTy _dictBuildNm _dictTag _derivAltsPrOcc _derivExtraPrOcc) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              { _mkf | _mkf `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              (case (tyPrLToSupNmL _supPrTyL) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               { _supClsFldNmL | _supClsFldNmL `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               (case (__tup43) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                { (_,_,_,_chrCtxtArgUIDL,_,_,_,_,_) | _chrCtxtArgUIDL `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (case (mkAssumeBindings _chrCtxtArgUIDL _chrEvidBindMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 { _chrAssumeDeclsCtxtBindL | _chrAssumeDeclsCtxtBindL `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 (case (__tup43) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  { (_,_,_,_,_,_,_,_chrInstArgUID,_) | _chrInstArgUID `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (case (mkAssumeBindings [_chrInstArgUID] _chrEvidBindMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   { _chrAssumeDeclsInstBindL | _chrAssumeDeclsInstBindL `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   (case (__tup47) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    { (_,_,_,_,_,_,_,_,_chrSolveSuperEvidBindMp,_,_) | _chrSolveSuperEvidBindMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (case (mkAssumeBindings _chrCtxtArgUIDL _chrSolveSuperEvidBindMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     { _chrAssumeSuperBindL | _chrAssumeSuperBindL `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     (case (mkScopeBindings True _predScope _chrSolveDeclsScopeBindMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      { __tup50 | __tup50 `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      (case (__tup50) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       { (_chrScopeDeclsBindL,_) | _chrScopeDeclsBindL `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       (case (__tup47) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        { (_,_,_,_,_,_,_,_,_,_chrSolveSuperScopeBindMp,_) | _chrSolveSuperScopeBindMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (case (mkScopeBindings True _predScope _chrSolveSuperScopeBindMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         { __tup49 | __tup49 `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         (case (__tup49) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          { (_chrScopeSuperBindL,_) | _chrScopeSuperBindL `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          (case (__tup47) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           { (_,_,_,_,_,_,_,_chrSolveSuperEvidCBindL,_,_,_) | _chrSolveSuperEvidCBindL `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           (case (__tup45) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            { (_,_,_,_,_,_,_,_chrSolveDeclsEvidCBindL,_,_,_) | _chrSolveDeclsEvidCBindL `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (case (__tup44) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             { (_,_,_,_derivDCL) | _derivDCL `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             (case (__tup43) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              { (_,_,_,_,_,_,_chrSuperProveNmL,_,_) | _chrSuperProveNmL `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              (case (__tup43) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               { (_,_,_,_,_chrCtxtArgNmL,_,_,_,_) | _chrCtxtArgNmL `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               (case (let (bindL,cSubstInstL) =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               case instVariant_ of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 InstNormal   -> (_declsIvalCBindL,[])
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 InstDefault  -> (_declsIvalCBindL,[])
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 InstDeriving _
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | _derivCanBeDoneGeneric
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              -> unzip
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   [ (acoreBind1 fld $ acore1App f $ acoreBuiltinUndefined _lhsIopts,s)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | ((fld,dflt,_,_),fo,u) <- zip3 _generForFitsInL _foGenerDerivL (mkNewLevUIDL (length _generForFitsInL) _lUniq_bind)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   , let (f,s) = foAppLRCoeAsSubst _lhsIopts u fo _lhsIfinTyVarMp _cSubstDecls (acoreVar dflt)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   ]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | otherwise
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              -> ([ _mkf dcf | dcf <- dclFldL _derivDCL ],[])
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      in  ( mkInstanceCBindL
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _lhsIopts _lhsIsysfEnv _clgi _lhsIfinTyKiGam _lhsIdataGam instVariant_ _dictTag
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (_dictNm,_dictSelfNm,_dictBuildNm)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _finalTy _recTy
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (_supClsFldNmL,_chrSuperProveNmL,_chrCtxtArgNmL)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            bindL
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ( _chrAssumeDeclsInstBindL ++ _chrSolveDeclsEvidCBindL ++ _chrScopeDeclsBindL
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            , _chrSolveSuperEvidCBindL ++ _chrScopeSuperBindL
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            , _chrAssumeSuperBindL ++ _chrAssumeDeclsCtxtBindL
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            )
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          , foldr cSubstApp emptyCSubst cSubstInstL
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          )) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                { __tup57 | __tup57 `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (case (__tup57) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 { (_,_cSubstInst) | _cSubstInst `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 (case (cSubstApp _declsIcSubst _cSubstInst) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  { _lhsOcSubst | _lhsOcSubst `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (case (Seq.empty) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   { _lhsOerrSq | _lhsOerrSq `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   (case (_declsIffeCBindL) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    { _lhsOffeCBindL | _lhsOffeCBindL `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (case (_declsIffiCBindL) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     { _lhsOffiCBindL | _lhsOffiCBindL `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     (case (_declsIgathHiddenExports) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      { _lhsOgathHiddenExports | _lhsOgathHiddenExports `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      (case (_declsIgathLamMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       { _lhsOgathLamMp | _lhsOgathLamMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       (case (__tup47) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        { (_,_,_,_,_,_chrSuperSimplifyResult,_,_,_,_,_) | _chrSuperSimplifyResult `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (case (__tup45) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         { (_,_,_,_,_,_chrDeclsSimplifyResult,_,_,_,_,_) | _chrDeclsSimplifyResult `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         (case (mentrelFilterMpUnions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  [ mentrelFilterMpSingleton [_lhsImoduleNm] IdOcc_Val (clgiDfltDictNm _clgi)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  , _declsIgathMentrelFilterMp
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  , gathMentrelFilterMpFromSimplifyResult _lhsImoduleNm _chrDeclsSimplifyResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  , gathMentrelFilterMpFromSimplifyResult _lhsImoduleNm _chrSuperSimplifyResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ]) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          { _gathMentrelFilterMp | _gathMentrelFilterMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          (case (_gathMentrelFilterMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           { _lhsOgathMentrelFilterMp | _lhsOgathMentrelFilterMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           (case (_declsIgathTvKiVarMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            { _lhsOgathTvKiVarMp | _lhsOgathTvKiVarMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (case (map (tyCanonic (emptyTyBetaRedEnv' _fe)) _instArgTyL) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             { _finalHdInstArgLExpanded | _finalHdInstArgLExpanded `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             (case (Set.unions [ orphanNmS _lhsImoduleNm c | t <- _finalHdInstArgLExpanded, c <- Set.toList $ tyAllConS t ]) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              { _tyOrphanS | _tyOrphanS `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              (case (orphanNmS _lhsImoduleNm _instClsNm) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               { _clsOrphanS | _clsOrphanS `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               (case (if not (Set.null _clsOrphanS || Set.null _tyOrphanS)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      then _clsOrphanS `Set.union` _tyOrphanS
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      else Set.empty) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                { _orphanS | _orphanS `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (case (_orphanS) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 { _lhsOorphanS | _lhsOorphanS `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 (case (ppErrsSq _declsIerrSq) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  { _errDeclsPP | _errDeclsPP `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (case (ppErrsSq _lErrSq) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   { _errInstPP | _errInstPP `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   (case ("instance"  >|< maybe empty (\(n,e) -> " " >|< n >#< (if e then "<:" else "::")) mbNmElim_
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      >#< _tyPrExprIpp
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      >#< "where"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      >#< ppCmt (pp $ show instVariant_)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      >-< indent 2 _declsIpp
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      >-< _errInstPP
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      >-< _errDeclsPP) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    { _pp | _pp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (case (_pp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     { _lhsOpp | _lhsOpp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     (case ((_lhsItr TraceOn_EhClsGam $ [_dictNm >#< " = Instance" >|< ppParens instVariant_ >#< _instClsNm] ++ [ "clgi=" >#< _clgi ])) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      { _trppHere | _trppHere `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      (case (ppNestTrPP _lhsIopts ["Decl","Instance"] (maybe [] (\(n,_) -> [ppTrNm n]) mbNmElim_) [_tyPrExprIppAST,_declsIppAST] _trppHere) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       { _ppAST | _ppAST `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       (case (_ppAST) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        { _lhsOppAST | _lhsOppAST `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (case (_trppHere >< _tyPrExprItrpp >< _declsItrpp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         { _trpp | _trpp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         (case (_trpp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          { _lhsOtrpp | _lhsOtrpp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          (case (_declsItyCBindL) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           { _lhsOtyCBindL | _lhsOtyCBindL `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           (case (__tup57) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            { (_lhsOvalCBindL,_) | _lhsOvalCBindL `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ( _lhsOallErrSq,_lhsObangEvalL,_lhsOcSubst,_lhsOerrSq,_lhsOffeCBindL,_lhsOffiCBindL,_lhsOgathHiddenExports,_lhsOgathLamMp,_lhsOgathMentrelFilterMp,_lhsOgathTvKiVarMp,_lhsOorphanS,_lhsOpp,_lhsOppAST,_lhsOtrpp,_lhsOtyCBindL,_lhsOvalCBindL) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) })))))))))))))
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                in  sem_Decl_Instance_14)) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         { ( sem_Decl_14) | True ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         ( _lhsOgathCnstrMp,_lhsOgathRangeMp,_lhsOintlTyKiGam,_lhsOnoLetQuantTyVarIdS,_lhsOscopeGam,_lhsOtyVarMp,sem_Decl_14) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }))))))))
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      in  sem_Decl_Instance_13)) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               { ( sem_Decl_13) | True ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               ( _lhsOpatTyVarMp,_lhsOpatValGam,sem_Decl_13) }) }) }) }) }) }) }) }) }) })))))))
                                                                                                                                                                                                                                                                                                                                                                                                                                                                   in  sem_Decl_Instance_12)) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                            { ( sem_Decl_12) | True ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                            ( _lhsOchrClassDeclSq,_lhsOchrInstDeclSq,_lhsOgathClDfGam,sem_Decl_12) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) })))
                                                                                                                                                                                                                                                                                                                                                                                                                       in  sem_Decl_Instance_11)) of
                                                                                                                                                                                                                                                                                                                                                                                                                { ( sem_Decl_11) | True ->
                                                                                                                                                                                                                                                                                                                                                                                                                ( _lhsOgathDataGam,_lhsOgathDeclDataGam,_lhsOgathTySigGam,_lhsOgathTySigVarMp,sem_Decl_11) }) }) }) }) }) }) }) }) }) }))))
                                                                                                                                                                                                                                                                                                                                                                               in  sem_Decl_Instance_10)) of
                                                                                                                                                                                                                                                                                                                                                                        { ( sem_Decl_10) | True ->
                                                                                                                                                                                                                                                                                                                                                                        ( _lhsOpatClGam2,sem_Decl_10) }) }) }) }) }) }) }))))))
                                                                                                                                                                                                                                                                                                                                            in  sem_Decl_Instance_9)) of
                                                                                                                                                                                                                                                                                                                                     { ( sem_Decl_9) | True ->
                                                                                                                                                                                                                                                                                                                                     ( _lhsOpatClGam1,sem_Decl_9) }) }) }) })))
                                                                                                                                                                                                                                                                                                               in  sem_Decl_Instance_8)) of
                                                                                                                                                                                                                                                                                                        { ( sem_Decl_8) | True ->
                                                                                                                                                                                                                                                                                                        ( _lhsOgenerDataInfoL,_lhsOgenerDataInfoMp,_lhsOkiVarMp,_lhsOpolVarMp,sem_Decl_8) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }))))))))))
                                                                                                                                                                                                                             in  sem_Decl_Instance_7)) of
                                                                                                                                                                                                                      { ( sem_Decl_7) | True ->
                                                                                                                                                                                                                      ( _lhsOpatKiVarMp,_lhsOpatPolGam,sem_Decl_7) }) }) })))))
                                                                                                                                                                                                   in  sem_Decl_Instance_6)) of
                                                                                                                                                                                            { ( sem_Decl_6) | True ->
                                                                                                                                                                                            ( _lhsOpatTyKiGam,_lhsOtyTyVarMp,sem_Decl_6) }) }) }) }) }) }) }) }) }) }) }) }) }) }) })))))
                                                                                                                                             in  sem_Decl_Instance_5)) of
                                                                                                                                      { ( sem_Decl_5) | True ->
                                                                                                                                      ( _lhsOpatTyGam,sem_Decl_5) }) }))))
                                                                                                                     in  sem_Decl_Instance_4)) of
                                                                                                              { ( sem_Decl_4) | True ->
                                                                                                              ( _lhsOpredSameScopeCounter,sem_Decl_4) }) }))))
                                                                                             in  sem_Decl_Instance_3)) of
                                                                                      { ( sem_Decl_3) | True ->
                                                                                      ( _lhsOgathTyKiSigGam,sem_Decl_3) }) }) }) })))
                                                                in  sem_Decl_Instance_2)) of
                                                         { ( sem_Decl_2) | True ->
                                                         ( _lhsOgUniq,_lhsOgathKiSigGam,_lhsOhasInstDecl,sem_Decl_2) }) }) }) }) }) }) }) }) }) }))))
                        in  sem_Decl_Instance_1)) of
                 { ( sem_Decl_1) | True ->
                 ( _lhsOrange,sem_Decl_1) }) }) }) }) })

sem_Decl_InstanceIntro :: Range ->
                          (Maybe (HsName)) ->
                          T_Expr ->
                          T_PrExpr ->
                          T_Decl

sem_Decl_InstanceIntro hsrange_ mbNmElim_ expr_ prExpr_ | hsrange_ `seq` (mbNmElim_ `seq` (expr_ `seq` (prExpr_ `seq` (True)))) =
    (case (prExpr_) of
     { ( _prExprIrange,prExpr_1) | True ->
         (case (expr_) of
          { ( _exprIrange,expr_1) | True ->
              (case (rangeUnions [hsrange_, _exprIrange   , _prExprIrange]) of
               { _range | _range `seq` (True) ->
               (case (_range) of
                { _lhsOrange | _lhsOrange `seq` (True) ->
                (case ((let sem_Decl_InstanceIntro_1 :: T_Decl_1
                            sem_Decl_InstanceIntro_1 =
                                (\ _lhsIgUniq
                                   _lhsIgathKiSigGam ->
                                     _lhsIgUniq `seq`
                                     (_lhsIgathKiSigGam `seq`
                                      ((case (let __cont = _lhsIgUniq in seq __cont ( case nextUnique __cont of { (__cont, lUniq) -> case nextUnique __cont of { (__cont, lUniq_17_polCtx) -> case nextUnique __cont of { (__cont, lUniq_9_prTyMeta) -> (__cont,lUniq,lUniq_17_polCtx,lUniq_9_prTyMeta)}}} )) of
                                        { __tup60 | __tup60 `seq` (True) ->
                                        (case (__tup60) of
                                         { (_exprOgUniq,_,_,_) | _exprOgUniq `seq` (True) ->
                                         (case (expr_1 _exprOgUniq) of
                                          { ( _exprIgUniq,_exprIhasInstDecl,expr_2) | True ->
                                              (case (_exprIgUniq) of
                                               { _prExprOgUniq | _prExprOgUniq `seq` (True) ->
                                               (case (prExpr_1 _prExprOgUniq) of
                                                { ( _prExprIgUniq,prExpr_2) | True ->
                                                    (case (_prExprIgUniq) of
                                                     { _lhsOgUniq | _lhsOgUniq `seq` (True) ->
                                                     (case (_lhsIgathKiSigGam) of
                                                      { _lhsOgathKiSigGam | _lhsOgathKiSigGam `seq` (True) ->
                                                      (case (True) of
                                                       { _lhsOhasInstDecl | _lhsOhasInstDecl `seq` (True) ->
                                                       (case ((let sem_Decl_InstanceIntro_2 :: T_Decl_2
                                                                   sem_Decl_InstanceIntro_2 =
                                                                       (\ _lhsIkiGam ->
                                                                            _lhsIkiGam `seq`
                                                                            ((case (emptyGam) of
                                                                              { _lhsOgathTyKiSigGam | _lhsOgathTyKiSigGam `seq` (True) ->
                                                                              (case ((let sem_Decl_InstanceIntro_3 :: T_Decl_3
                                                                                          sem_Decl_InstanceIntro_3 =
                                                                                              (\ _lhsIlexLev
                                                                                                 _lhsIpredSameScopeCounter ->
                                                                                                   _lhsIlexLev `seq`
                                                                                                   (_lhsIpredSameScopeCounter `seq`
                                                                                                    ((case (_lhsIpredSameScopeCounter) of
                                                                                                      { _exprOpredSameScopeCounter | _exprOpredSameScopeCounter `seq` (True) ->
                                                                                                      (case (_lhsIlexLev) of
                                                                                                       { _exprOlexLev | _exprOlexLev `seq` (True) ->
                                                                                                       (case (_lhsIkiGam) of
                                                                                                        { _exprOkiGam | _exprOkiGam `seq` (True) ->
                                                                                                        (case (True) of
                                                                                                         { _exprOisFirstLet | _exprOisFirstLet `seq` (True) ->
                                                                                                         (case (expr_2 _exprOisFirstLet _exprOkiGam _exprOlexLev _exprOpredSameScopeCounter) of
                                                                                                          { ( _exprIpredSameScopeCounter,expr_3) | True ->
                                                                                                              (case (_exprIpredSameScopeCounter) of
                                                                                                               { _lhsOpredSameScopeCounter | _lhsOpredSameScopeCounter `seq` (True) ->
                                                                                                               (case ((let sem_Decl_InstanceIntro_4 :: T_Decl_4
                                                                                                                           sem_Decl_InstanceIntro_4 =
                                                                                                                               (\ _lhsIpatTyGam
                                                                                                                                  _lhsItyKiSigGam ->
                                                                                                                                    _lhsIpatTyGam `seq`
                                                                                                                                    (_lhsItyKiSigGam `seq`
                                                                                                                                     ((case (_lhsIpatTyGam) of
                                                                                                                                       { _lhsOpatTyGam | _lhsOpatTyGam `seq` (True) ->
                                                                                                                                       (case ((let sem_Decl_InstanceIntro_5 :: T_Decl_5
                                                                                                                                                   sem_Decl_InstanceIntro_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_Decl_InstanceIntro_6 :: T_Decl_6
                                                                                                                                                                             sem_Decl_InstanceIntro_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_Decl_InstanceIntro_7 :: T_Decl_7
                                                                                                                                                                                                       sem_Decl_InstanceIntro_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 (_lhsItyKiGlobFreeTvarS) of
                                                                                                                                                                                                                          { _exprOtyKiGlobFreeTvarS | _exprOtyKiGlobFreeTvarS `seq` (True) ->
                                                                                                                                                                                                                          (case (_lhsItyKiGam) of
                                                                                                                                                                                                                           { _exprOtyKiGam | _exprOtyKiGam `seq` (True) ->
                                                                                                                                                                                                                           (case (_lhsItyGam) of
                                                                                                                                                                                                                            { _exprOtyGam | _exprOtyGam `seq` (True) ->
                                                                                                                                                                                                                            (case (_lhsIpredScope) of
                                                                                                                                                                                                                             { _exprOpredScope | _exprOpredScope `seq` (True) ->
                                                                                                                                                                                                                             (case (_lhsIpolVarMp) of
                                                                                                                                                                                                                              { _exprOpolVarMp | _exprOpolVarMp `seq` (True) ->
                                                                                                                                                                                                                              (case (_lhsIpolGam) of
                                                                                                                                                                                                                               { _exprOpolGam | _exprOpolGam `seq` (True) ->
                                                                                                                                                                                                                               (case (_lhsIopts) of
                                                                                                                                                                                                                                { _exprOopts | _exprOopts `seq` (True) ->
                                                                                                                                                                                                                                (case (_lhsIkiVarMp) of
                                                                                                                                                                                                                                 { _exprOkiVarMp | _exprOkiVarMp `seq` (True) ->
                                                                                                                                                                                                                                 (case (_lhsIgenerDataInfoMp) of
                                                                                                                                                                                                                                  { _exprOgenerDataInfoMp | _exprOgenerDataInfoMp `seq` (True) ->
                                                                                                                                                                                                                                  (case (expr_3 _exprOgenerDataInfoMp _exprOkiVarMp _exprOopts _exprOpolGam _exprOpolVarMp _exprOpredScope _exprOtyGam _exprOtyKiGam _exprOtyKiGlobFreeTvarS) of
                                                                                                                                                                                                                                   { ( _exprIgenerDataInfoMp,_exprIkiVarMp,_exprIpolVarMp,expr_4) | True ->
                                                                                                                                                                                                                                       (case (_exprIgenerDataInfoMp) of
                                                                                                                                                                                                                                        { _lhsOgenerDataInfoMp | _lhsOgenerDataInfoMp `seq` (True) ->
                                                                                                                                                                                                                                        (case (_lhsItyKiGam) of
                                                                                                                                                                                                                                         { _prExprOtyKiGam | _prExprOtyKiGam `seq` (True) ->
                                                                                                                                                                                                                                         (case (_lhsItyGam) of
                                                                                                                                                                                                                                          { _prExprOtyGam | _prExprOtyGam `seq` (True) ->
                                                                                                                                                                                                                                          (case (_exprIpolVarMp) of
                                                                                                                                                                                                                                           { _prExprOpolVarMp | _prExprOpolVarMp `seq` (True) ->
                                                                                                                                                                                                                                           (case (_lhsIpolGam) of
                                                                                                                                                                                                                                            { _prExprOpolGam | _prExprOpolGam `seq` (True) ->
                                                                                                                                                                                                                                            (case (_exprIkiVarMp) of
                                                                                                                                                                                                                                             { _prExprOkiVarMp | _prExprOkiVarMp `seq` (True) ->
                                                                                                                                                                                                                                             (case (__tup60) of
                                                                                                                                                                                                                                              { (_,_,_lUniq_17_polCtx,_) | _lUniq_17_polCtx `seq` (True) ->
                                                                                                                                                                                                                                              (case (mkPolVar _lUniq_17_polCtx) of
                                                                                                                                                                                                                                               { _prExprOknPolCtx | _prExprOknPolCtx `seq` (True) ->
                                                                                                                                                                                                                                               (case (prExpr_2 _prExprOtyGam) of
                                                                                                                                                                                                                                                { ( _prExprIprTy,_prExprIty,_prExprItyGam,prExpr_3) | True ->
                                                                                                                                                                                                                                                    (case (prExpr_3 _prExprOknPolCtx) of
                                                                                                                                                                                                                                                     { ( _prExprIpolVarL,prExpr_4) | True ->
                                                                                                                                                                                                                                                         (case (prExpr_4 _prExprOpolGam _prExprOpolVarMp) of
                                                                                                                                                                                                                                                          { ( _prExprIpolVarMp,prExpr_5) | True ->
                                                                                                                                                                                                                                                              (case (prExpr_5 _prExprOtyKiGam) of
                                                                                                                                                                                                                                                               { ( _prExprIintlTyKiGam,_prExprItyKiGam,prExpr_6) | True ->
                                                                                                                                                                                                                                                                   (case (prExpr_6 _prExprOkiVarMp) of
                                                                                                                                                                                                                                                                    { ( _prExprIgathTyVarPolGam,_prExprIki,_prExprIkiVarMp,_prExprItyVarWildMp,prExpr_7) | True ->
                                                                                                                                                                                                                                                                        (case (_prExprIkiVarMp) of
                                                                                                                                                                                                                                                                         { _lhsOkiVarMp | _lhsOkiVarMp `seq` (True) ->
                                                                                                                                                                                                                                                                         (case (_prExprIpolVarMp) of
                                                                                                                                                                                                                                                                          { _lhsOpolVarMp | _lhsOpolVarMp `seq` (True) ->
                                                                                                                                                                                                                                                                          (case ((let sem_Decl_InstanceIntro_8 :: T_Decl_8
                                                                                                                                                                                                                                                                                      sem_Decl_InstanceIntro_8 =
                                                                                                                                                                                                                                                                                          (\ _lhsIpatClGam1 ->
                                                                                                                                                                                                                                                                                               _lhsIpatClGam1 `seq`
                                                                                                                                                                                                                                                                                               ((case (_lhsIpatClGam1) of
                                                                                                                                                                                                                                                                                                 { _lhsOpatClGam1 | _lhsOpatClGam1 `seq` (True) ->
                                                                                                                                                                                                                                                                                                 (case ((let sem_Decl_InstanceIntro_9 :: T_Decl_9
                                                                                                                                                                                                                                                                                                             sem_Decl_InstanceIntro_9 =
                                                                                                                                                                                                                                                                                                                 (\ _lhsIfinKiVarMp
                                                                                                                                                                                                                                                                                                                    _lhsIfinTyKiGam
                                                                                                                                                                                                                                                                                                                    _lhsIpatClGam2
                                                                                                                                                                                                                                                                                                                    _lhsItyTyTySigFreeTvarS ->
                                                                                                                                                                                                                                                                                                                      _lhsIfinKiVarMp `seq`
                                                                                                                                                                                                                                                                                                                      (_lhsIfinTyKiGam `seq`
                                                                                                                                                                                                                                                                                                                       (_lhsIpatClGam2 `seq`
                                                                                                                                                                                                                                                                                                                        (_lhsItyTyTySigFreeTvarS `seq`
                                                                                                                                                                                                                                                                                                                         ((case (_lhsIpatClGam2) of
                                                                                                                                                                                                                                                                                                                           { _lhsOpatClGam2 | _lhsOpatClGam2 `seq` (True) ->
                                                                                                                                                                                                                                                                                                                           (case ((let sem_Decl_InstanceIntro_10 :: T_Decl_10
                                                                                                                                                                                                                                                                                                                                       sem_Decl_InstanceIntro_10 =
                                                                                                                                                                                                                                                                                                                                           (\ _lhsIclGam
                                                                                                                                                                                                                                                                                                                                              _lhsIgathDataGam ->
                                                                                                                                                                                                                                                                                                                                                _lhsIclGam `seq`
                                                                                                                                                                                                                                                                                                                                                (_lhsIgathDataGam `seq`
                                                                                                                                                                                                                                                                                                                                                 ((case (_lhsItyTyTySigFreeTvarS) of
                                                                                                                                                                                                                                                                                                                                                   { _exprOtyTyTySigFreeTvarS | _exprOtyTyTySigFreeTvarS `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                   (case (_lhsIgathDataGam) of
                                                                                                                                                                                                                                                                                                                                                    { _exprOgathDataGam | _exprOgathDataGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                    (case (_lhsIfinTyKiGam) of
                                                                                                                                                                                                                                                                                                                                                     { _exprOfinTyKiGam | _exprOfinTyKiGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                     (case (_lhsIfinKiVarMp) of
                                                                                                                                                                                                                                                                                                                                                      { _exprOfinKiVarMp | _exprOfinKiVarMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                      (case (_lhsIclGam) of
                                                                                                                                                                                                                                                                                                                                                       { _exprOclGam | _exprOclGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                       (case (expr_4 _exprOclGam _exprOfinKiVarMp _exprOfinTyKiGam _exprOgathDataGam _exprOtyTyTySigFreeTvarS) of
                                                                                                                                                                                                                                                                                                                                                        { ( _exprIgathDataGam,expr_5) | True ->
                                                                                                                                                                                                                                                                                                                                                            (case (_exprIgathDataGam) 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_Decl_InstanceIntro_11 :: T_Decl_11
                                                                                                                                                                                                                                                                                                                                                                            sem_Decl_InstanceIntro_11 =
                                                                                                                                                                                                                                                                                                                                                                                (\ _lhsIdataGam ->
                                                                                                                                                                                                                                                                                                                                                                                     _lhsIdataGam `seq`
                                                                                                                                                                                                                                                                                                                                                                                     ((case (_lhsIdataGam) of
                                                                                                                                                                                                                                                                                                                                                                                       { _exprOdataGam | _exprOdataGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                       (case (expr_5 _exprOdataGam) of
                                                                                                                                                                                                                                                                                                                                                                                        { ( _exprIchrClassDeclSq,_exprIchrFIIn,_exprIchrInstDeclSq,_exprIgathClDfGam,expr_6) | True ->
                                                                                                                                                                                                                                                                                                                                                                                            (case (_exprIchrClassDeclSq) of
                                                                                                                                                                                                                                                                                                                                                                                             { _lhsOchrClassDeclSq | _lhsOchrClassDeclSq `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                             (case (__tup60) of
                                                                                                                                                                                                                                                                                                                                                                                              { (_,_,_,_lUniq_9_prTyMeta) | _lUniq_9_prTyMeta `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                              (case (__tup60) of
                                                                                                                                                                                                                                                                                                                                                                                               { (_,_lUniq,_,_) | _lUniq `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                               (case (mkPrIdCHR _lUniq) of
                                                                                                                                                                                                                                                                                                                                                                                                { _instId | _instId `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                (case (maybe (poiHNm _instId) id mbNmElim_) of
                                                                                                                                                                                                                                                                                                                                                                                                 { _dictNm | _dictNm `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                 (case (let pr = tyPred $ tyMetaTyVars _lUniq_9_prTyMeta _prExprIty
                                                                                                                                                                                                                                                                                                                                                                                                        in  ( []
                                                                                                                                                                                                                                                                                                                                                                                                            , pr
                                                                                                                                                                                                                                                                                                                                                                                                            , RedHow_ByInstance _dictNm pr _lhsIpredScope
                                                                                                                                                                                                                                                                                                                                                                                                            , _lhsIpredScope
                                                                                                                                                                                                                                                                                                                                                                                                            )) of
                                                                                                                                                                                                                                                                                                                                                                                                  { _chrInstDecl | _chrInstDecl `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                  (case (Seq.singleton _chrInstDecl) of
                                                                                                                                                                                                                                                                                                                                                                                                   { _lhsOchrInstDeclSq | _lhsOchrInstDeclSq `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                   (case (_exprIgathClDfGam) of
                                                                                                                                                                                                                                                                                                                                                                                                    { _lhsOgathClDfGam | _lhsOgathClDfGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                    (case ((let sem_Decl_InstanceIntro_12 :: T_Decl_12
                                                                                                                                                                                                                                                                                                                                                                                                                sem_Decl_InstanceIntro_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_Decl_InstanceIntro_13 :: T_Decl_13
                                                                                                                                                                                                                                                                                                                                                                                                                                            sem_Decl_InstanceIntro_13 =
                                                                                                                                                                                                                                                                                                                                                                                                                                                (\ _lhsIchrStore
                                                                                                                                                                                                                                                                                                                                                                                                                                                   _lhsIclDfGam
                                                                                                                                                                                                                                                                                                                                                                                                                                                   _lhsItyTyGlobFreeTvarS
                                                                                                                                                                                                                                                                                                                                                                                                                                                   _lhsItyVarMp
                                                                                                                                                                                                                                                                                                                                                                                                                                                   _lhsIvalGam
                                                                                                                                                                                                                                                                                                                                                                                                                                                   _lhsIvalTyGlobFreeTvarS ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                     _lhsIchrStore `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                                                     (_lhsIclDfGam `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                                                      (_lhsItyTyGlobFreeTvarS `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                                                       (_lhsItyVarMp `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                                                        (_lhsIvalGam `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                                                         (_lhsIvalTyGlobFreeTvarS `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                                                          ((case (_lhsIvalTyGlobFreeTvarS) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                            { _exprOvalTyGlobFreeTvarS | _exprOvalTyGlobFreeTvarS `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                            (case (_lhsIvalGam) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                             { _exprOvalGam | _exprOvalGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                             (case (_lhsItyTyGlobFreeTvarS) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                              { _exprOtyTyGlobFreeTvarS | _exprOtyTyGlobFreeTvarS `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                              (case (_lhsItvKiVarMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                               { _exprOtvKiVarMp | _exprOtvKiVarMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                               (case (_lhsIclDfGam) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                { _exprOclDfGam | _exprOclDfGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                (case (_lhsIchrStore) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                 { _exprOchrStore | _exprOchrStore `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                 (case (strongFIOpts) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  { _exprOfiOpts | _exprOfiOpts `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (case (fitPredToEvid'' clgiPrToEvidDataTy _lUniq emptyVarMp _prExprIty (Right _lhsIclGam)) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                   { _foPr | _foPr `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                   (case (foVarMp _foPr `varUpd` _lhsItyVarMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    { _exprOtyVarMp | _exprOtyVarMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (case (foTy _foPr) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                     { _exprOknTy | _exprOknTy `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                     (case (expr_6 _exprOchrStore _exprOclDfGam _exprOfiOpts _exprOknTy _exprOtvKiVarMp _exprOtyTyGlobFreeTvarS _exprOtyVarMp _exprOvalGam _exprOvalTyGlobFreeTvarS) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      { ( _exprIgathCnstrMp,_exprIgathRangeMp,_exprIgathValGam,_exprInoLetQuantTyVarIdS,_exprIty,_exprItyVarMp,expr_7) | True ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          (case (_exprIgathCnstrMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                           { _lhsOgathCnstrMp | _lhsOgathCnstrMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                           (case (_exprIgathRangeMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            { _lhsOgathRangeMp | _lhsOgathRangeMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (case (_prExprIintlTyKiGam) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                             { _lhsOintlTyKiGam | _lhsOintlTyKiGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                             (case (_exprInoLetQuantTyVarIdS) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              { _lhsOnoLetQuantTyVarIdS | _lhsOnoLetQuantTyVarIdS `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              (case (emptyGam) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                               { _lhsOscopeGam | _lhsOscopeGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                               (case (_exprItyVarMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                { _lhsOtyVarMp | _lhsOtyVarMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (case ((let sem_Decl_InstanceIntro_14 :: T_Decl_14
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            sem_Decl_InstanceIntro_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 (_lhsIopts) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 { _prExprOopts | _prExprOopts `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 (case (_lhsIclGam) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  { _prExprOclGam | _prExprOclGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (case (_lhsIsysfEnv) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   { _exprOsysfEnv | _exprOsysfEnv `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   (case (_lhsIrangeMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    { _exprOrangeMp | _exprOrangeMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (case (_lhsIfinValGam) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     { _exprOfinValGam | _exprOfinValGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     (case (_lhsIfinTyVarMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      { _exprOfinTyVarMp | _exprOfinTyVarMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      (case (ExprCtxt_Top) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       { _exprOexprCtxt | _exprOexprCtxt `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       (case (if Set.null (varFreeSet _prExprIty) then [] else [rngLift _range Err_TyHasFreeTVars _prExprIty]) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        { _predErrs | _predErrs `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (case (prExpr_7 _prExprOclGam) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         { ( _prExprIevTy,prExpr_8) | True ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             (case (_lhsIvalTyGlobFreeTvarS) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              { _prExprOvalTyGlobFreeTvarS | _prExprOvalTyGlobFreeTvarS `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              (case (_lhsItyTyTySigFreeTvarS) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               { _prExprOtyTyTySigFreeTvarS | _prExprOtyTyTySigFreeTvarS `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               (case (_lhsItyTyGlobFreeTvarS) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                { _prExprOtyTyGlobFreeTvarS | _prExprOtyTyGlobFreeTvarS `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (case (_lhsItyKiGlobFreeTvarS) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 { _prExprOtyKiGlobFreeTvarS | _prExprOtyKiGlobFreeTvarS `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 (case (_lhsItr) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  { _prExprOtr | _prExprOtr `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (case (_lhsIsysfEnv) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   { _prExprOsysfEnv | _prExprOsysfEnv `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   (case (_lhsImoduleNm) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    { _prExprOmoduleNm | _prExprOmoduleNm `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (case (_lhsIkiGam) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     { _prExprOkiGam | _prExprOkiGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     (case (_lhsIfinTyVarMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      { _prExprOfinTyVarMp | _prExprOfinTyVarMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      (case (_lhsIfinTyKiGam) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       { _prExprOfinTyKiGam | _prExprOfinTyKiGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       (case (_lhsIfinKiVarMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        { _prExprOfinKiVarMp | _prExprOfinKiVarMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (case (prExpr_8 _prExprOfinKiVarMp _prExprOfinTyKiGam _prExprOfinTyVarMp _prExprOkiGam _prExprOmoduleNm _prExprOopts _prExprOsysfEnv _prExprOtr _prExprOtyKiGlobFreeTvarS _prExprOtyTyGlobFreeTvarS _prExprOtyTyTySigFreeTvarS _prExprOvalTyGlobFreeTvarS) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         { ( _prExprIallErrSq,_prExprIclMissNmS,_prExprIclNmS,_prExprIerrSq,_prExprIgathMentrelFilterMp,_prExprIpp,_prExprIppAST,_prExprIpr,_prExprItrpp) | True ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             (case (_lhsItr) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              { _exprOtr | _exprOtr `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              (case (_lhsImoduleNm) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               { _exprOmoduleNm | _exprOmoduleNm `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               (case (_lhsIchrScopeBindMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                { _exprOchrScopeBindMp | _exprOchrScopeBindMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (case (_lhsIchrEvidBindMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 { _exprOchrEvidBindMp | _exprOchrEvidBindMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 (case (_lhsIcSubst) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  { _exprOcSubst | _exprOcSubst `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (case (expr_7 _exprOcSubst _exprOchrEvidBindMp _exprOchrScopeBindMp _exprOexprCtxt _exprOfinTyVarMp _exprOfinValGam _exprOmoduleNm _exprOrangeMp _exprOsysfEnv _exprOtr) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   { ( _exprIallErrSq,_exprIappArgCoeL,_exprIappArgPPL,_exprIappFunCExpr,_exprIappFunNm,_exprIappFunPP,_exprIbackCBindL,_exprIcSubst,_exprIcaseFailS,_exprIcexpr,_exprIerrSq,_exprIfrontCBindL,_exprIfuCExprL,_exprIgathClGam,_exprIgathHiddenExports,_exprIgathKiGam,_exprIgathLamMp,_exprIgathMentrelFilterMp,_exprIgathPolGam,_exprIgathTvKiVarMp,_exprIgathTyGam,_exprIgathTyKiGam,_exprIisNewtype,_exprIlamArgPPL,_exprIlamBodyPP,_exprIletCBody,_exprIletTyCBindL,_exprIletValCBindL,_exprIletValMainCBindL,_exprIorphanS,_exprIpp,_exprIppAST,_exprItrpp) | True ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       (case (Seq.unions [ _exprIerrSq, _prExprIerrSq
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         , foErrSq _foPr, Seq.fromList _predErrs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         ]) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        { _lErrSq | _lErrSq `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (case (_lErrSq) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         { _lhsOallErrSq | _lhsOallErrSq `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         (case ([]) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          { _lhsObangEvalL | _lhsObangEvalL `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          (case (_exprIcSubst) 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 (_exprIgathHiddenExports) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               { _lhsOgathHiddenExports | _lhsOgathHiddenExports `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               (case (_exprIgathLamMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                { _lhsOgathLamMp | _lhsOgathLamMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (case (_exprIgathMentrelFilterMp `mentrelFilterMpUnion` _prExprIgathMentrelFilterMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 { _lhsOgathMentrelFilterMp | _lhsOgathMentrelFilterMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 (case (_exprIgathTvKiVarMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  { _lhsOgathTvKiVarMp | _lhsOgathTvKiVarMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (case (_exprIorphanS) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   { _lhsOorphanS | _lhsOorphanS `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   (case (ppErrsSq _lErrSq) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    { _errInstPP | _errInstPP `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (case ("instance"  >#< _exprIpp >#< "<:" >#< _prExprIpp
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       >-< _errInstPP) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     { _pp | _pp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     (case (_pp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      { _lhsOpp | _lhsOpp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      (case (trppEmpty) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       { _trppHere | _trppHere `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       (case (ppNestTrPP _lhsIopts ["Decl","InstanceIntro"] [] [_exprIppAST,_prExprIppAST] _trppHere) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        { _ppAST | _ppAST `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (case (_ppAST) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         { _lhsOppAST | _lhsOppAST `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         (case (_exprItrpp >< _prExprItrpp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          { _lhsOtrpp | _lhsOtrpp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          (case ([]) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           { _lhsOtyCBindL | _lhsOtyCBindL `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           (case ([acoreBind1MetaTy _dictNm CMetaVal_Dict (acoreTyErr $ "EH.ToCore.Decl.InstanceIntro.valCBindL: " ++ show _dictNm) _exprIcexpr]) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            { _lhsOvalCBindL | _lhsOvalCBindL `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ( _lhsOallErrSq,_lhsObangEvalL,_lhsOcSubst,_lhsOerrSq,_lhsOffeCBindL,_lhsOffiCBindL,_lhsOgathHiddenExports,_lhsOgathLamMp,_lhsOgathMentrelFilterMp,_lhsOgathTvKiVarMp,_lhsOorphanS,_lhsOpp,_lhsOppAST,_lhsOtrpp,_lhsOtyCBindL,_lhsOvalCBindL) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) })))))))))))))
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        in  sem_Decl_InstanceIntro_14)) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 { ( sem_Decl_14) | True ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 ( _lhsOgathCnstrMp,_lhsOgathRangeMp,_lhsOintlTyKiGam,_lhsOnoLetQuantTyVarIdS,_lhsOscopeGam,_lhsOtyVarMp,sem_Decl_14) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }))))))))
                                                                                                                                                                                                                                                                                                                                                                                                                                        in  sem_Decl_InstanceIntro_13)) of
                                                                                                                                                                                                                                                                                                                                                                                                                                 { ( sem_Decl_13) | True ->
                                                                                                                                                                                                                                                                                                                                                                                                                                 ( _lhsOpatTyVarMp,_lhsOpatValGam,sem_Decl_13) }) }) })))))))
                                                                                                                                                                                                                                                                                                                                                                                                            in  sem_Decl_InstanceIntro_12)) of
                                                                                                                                                                                                                                                                                                                                                                                                     { ( sem_Decl_12) | True ->
                                                                                                                                                                                                                                                                                                                                                                                                     ( _lhsOchrClassDeclSq,_lhsOchrInstDeclSq,_lhsOgathClDfGam,sem_Decl_12) }) }) }) }) }) }) }) }) }) }) })))
                                                                                                                                                                                                                                                                                                                                                                        in  sem_Decl_InstanceIntro_11)) of
                                                                                                                                                                                                                                                                                                                                                                 { ( sem_Decl_11) | True ->
                                                                                                                                                                                                                                                                                                                                                                 ( _lhsOgathDataGam,_lhsOgathDeclDataGam,_lhsOgathTySigGam,_lhsOgathTySigVarMp,sem_Decl_11) }) }) }) }) }) }) }) }) }) }) }))))
                                                                                                                                                                                                                                                                                                                                   in  sem_Decl_InstanceIntro_10)) of
                                                                                                                                                                                                                                                                                                                            { ( sem_Decl_10) | True ->
                                                                                                                                                                                                                                                                                                                            ( _lhsOpatClGam2,sem_Decl_10) }) }))))))
                                                                                                                                                                                                                                                                                                         in  sem_Decl_InstanceIntro_9)) of
                                                                                                                                                                                                                                                                                                  { ( sem_Decl_9) | True ->
                                                                                                                                                                                                                                                                                                  ( _lhsOpatClGam1,sem_Decl_9) }) })))
                                                                                                                                                                                                                                                                                  in  sem_Decl_InstanceIntro_8)) of
                                                                                                                                                                                                                                                                           { ( sem_Decl_8) | True ->
                                                                                                                                                                                                                                                                           ( _lhsOgenerDataInfoL,_lhsOgenerDataInfoMp,_lhsOkiVarMp,_lhsOpolVarMp,sem_Decl_8) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }))))))))))
                                                                                                                                                                                                   in  sem_Decl_InstanceIntro_7)) of
                                                                                                                                                                                            { ( sem_Decl_7) | True ->
                                                                                                                                                                                            ( _lhsOpatKiVarMp,_lhsOpatPolGam,sem_Decl_7) }) }) })))))
                                                                                                                                                                         in  sem_Decl_InstanceIntro_6)) of
                                                                                                                                                                  { ( sem_Decl_6) | True ->
                                                                                                                                                                  ( _lhsOpatTyKiGam,_lhsOtyTyVarMp,sem_Decl_6) }) }) })))))
                                                                                                                                               in  sem_Decl_InstanceIntro_5)) of
                                                                                                                                        { ( sem_Decl_5) | True ->
                                                                                                                                        ( _lhsOpatTyGam,sem_Decl_5) }) }))))
                                                                                                                       in  sem_Decl_InstanceIntro_4)) of
                                                                                                                { ( sem_Decl_4) | True ->
                                                                                                                ( _lhsOpredSameScopeCounter,sem_Decl_4) }) }) }) }) }) }) }))))
                                                                                      in  sem_Decl_InstanceIntro_3)) of
                                                                               { ( sem_Decl_3) | True ->
                                                                               ( _lhsOgathTyKiSigGam,sem_Decl_3) }) })))
                                                               in  sem_Decl_InstanceIntro_2)) of
                                                        { ( sem_Decl_2) | True ->
                                                        ( _lhsOgUniq,_lhsOgathKiSigGam,_lhsOhasInstDecl,sem_Decl_2) }) }) }) }) }) }) }) }) }))))
                        in  sem_Decl_InstanceIntro_1)) of
                 { ( sem_Decl_1) | True ->
                 ( _lhsOrange,sem_Decl_1) }) }) }) }) })

sem_Decl_Default :: Range ->
                    HsName ->
                    T_TyExprs ->
                    T_Decl

sem_Decl_Default hsrange_ nm_ tyExprs_ | hsrange_ `seq` (nm_ `seq` (tyExprs_ `seq` (True))) =
    (case (tyExprs_) of
     { ( _tyExprsIrange,tyExprs_1) | True ->
         (case (rangeUnions [hsrange_, _tyExprsIrange, _tyExprsIrange
                                                                    ]) of
          { _range | _range `seq` (True) ->
          (case (_range) of
           { _lhsOrange | _lhsOrange `seq` (True) ->
           (case ((let sem_Decl_Default_1 :: T_Decl_1
                       sem_Decl_Default_1 =
                           (\ _lhsIgUniq
                              _lhsIgathKiSigGam ->
                                _lhsIgUniq `seq`
                                (_lhsIgathKiSigGam `seq`
                                 ((case (let __cont = _lhsIgUniq in seq __cont ( case nextUnique __cont of { (__cont, lUniq_17_polCtx) -> (__cont,lUniq_17_polCtx)} )) of
                                   { __tup61 | __tup61 `seq` (True) ->
                                   (case (__tup61) of
                                    { (_tyExprsOgUniq,_) | _tyExprsOgUniq `seq` (True) ->
                                    (case (tyExprs_1 _tyExprsOgUniq) of
                                     { ( _tyExprsIgUniq,tyExprs_2) | True ->
                                         (case (_tyExprsIgUniq) of
                                          { _lhsOgUniq | _lhsOgUniq `seq` (True) ->
                                          (case (_lhsIgathKiSigGam) of
                                           { _lhsOgathKiSigGam | _lhsOgathKiSigGam `seq` (True) ->
                                           (case (False) of
                                            { _lhsOhasInstDecl | _lhsOhasInstDecl `seq` (True) ->
                                            (case ((let sem_Decl_Default_2 :: T_Decl_2
                                                        sem_Decl_Default_2 =
                                                            (\ _lhsIkiGam ->
                                                                 _lhsIkiGam `seq`
                                                                 ((case (emptyGam) of
                                                                   { _lhsOgathTyKiSigGam | _lhsOgathTyKiSigGam `seq` (True) ->
                                                                   (case ((let sem_Decl_Default_3 :: T_Decl_3
                                                                               sem_Decl_Default_3 =
                                                                                   (\ _lhsIlexLev
                                                                                      _lhsIpredSameScopeCounter ->
                                                                                        _lhsIlexLev `seq`
                                                                                        (_lhsIpredSameScopeCounter `seq`
                                                                                         ((case (_lhsIpredSameScopeCounter) of
                                                                                           { _lhsOpredSameScopeCounter | _lhsOpredSameScopeCounter `seq` (True) ->
                                                                                           (case ((let sem_Decl_Default_4 :: T_Decl_4
                                                                                                       sem_Decl_Default_4 =
                                                                                                           (\ _lhsIpatTyGam
                                                                                                              _lhsItyKiSigGam ->
                                                                                                                _lhsIpatTyGam `seq`
                                                                                                                (_lhsItyKiSigGam `seq`
                                                                                                                 ((case (_lhsIpatTyGam) of
                                                                                                                   { _lhsOpatTyGam | _lhsOpatTyGam `seq` (True) ->
                                                                                                                   (case ((let sem_Decl_Default_5 :: T_Decl_5
                                                                                                                               sem_Decl_Default_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_Decl_Default_6 :: T_Decl_6
                                                                                                                                                         sem_Decl_Default_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_Decl_Default_7 :: T_Decl_7
                                                                                                                                                                                   sem_Decl_Default_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 (_lhsItyKiGam) of
                                                                                                                                                                                                       { _tyExprsOtyKiGam | _tyExprsOtyKiGam `seq` (True) ->
                                                                                                                                                                                                       (case (_lhsItyGam) of
                                                                                                                                                                                                        { _tyExprsOtyGam | _tyExprsOtyGam `seq` (True) ->
                                                                                                                                                                                                        (case (_lhsIpolVarMp) of
                                                                                                                                                                                                         { _tyExprsOpolVarMp | _tyExprsOpolVarMp `seq` (True) ->
                                                                                                                                                                                                         (case (_lhsIpolGam) of
                                                                                                                                                                                                          { _tyExprsOpolGam | _tyExprsOpolGam `seq` (True) ->
                                                                                                                                                                                                          (case (_lhsIkiVarMp) of
                                                                                                                                                                                                           { _tyExprsOkiVarMp | _tyExprsOkiVarMp `seq` (True) ->
                                                                                                                                                                                                           (case (tyExprs_2 _tyExprsOtyGam) of
                                                                                                                                                                                                            { ( _tyExprsIpolVarL,_tyExprsItyGam,_tyExprsItyL,tyExprs_3) | True ->
                                                                                                                                                                                                                (case (tyExprs_3 _tyExprsOpolGam _tyExprsOpolVarMp) of
                                                                                                                                                                                                                 { ( _tyExprsIpolVarMp,tyExprs_4) | True ->
                                                                                                                                                                                                                     (case (tyExprs_4 _tyExprsOtyKiGam) of
                                                                                                                                                                                                                      { ( _tyExprsIintlTyKiGam,_tyExprsItyKiGam,tyExprs_5) | True ->
                                                                                                                                                                                                                          (case (tyExprs_5 _tyExprsOkiVarMp) of
                                                                                                                                                                                                                           { ( _tyExprsIgathTyVarPolGam,_tyExprsIkiL,_tyExprsIkiVarMp,_tyExprsItyVarWildMp,tyExprs_6) | True ->
                                                                                                                                                                                                                               (case (_tyExprsIkiVarMp) of
                                                                                                                                                                                                                                { _lhsOkiVarMp | _lhsOkiVarMp `seq` (True) ->
                                                                                                                                                                                                                                (case (_tyExprsIpolVarMp) of
                                                                                                                                                                                                                                 { _lhsOpolVarMp | _lhsOpolVarMp `seq` (True) ->
                                                                                                                                                                                                                                 (case ((let sem_Decl_Default_8 :: T_Decl_8
                                                                                                                                                                                                                                             sem_Decl_Default_8 =
                                                                                                                                                                                                                                                 (\ _lhsIpatClGam1 ->
                                                                                                                                                                                                                                                      _lhsIpatClGam1 `seq`
                                                                                                                                                                                                                                                      ((case (_lhsIpatClGam1) of
                                                                                                                                                                                                                                                        { _lhsOpatClGam1 | _lhsOpatClGam1 `seq` (True) ->
                                                                                                                                                                                                                                                        (case ((let sem_Decl_Default_9 :: T_Decl_9
                                                                                                                                                                                                                                                                    sem_Decl_Default_9 =
                                                                                                                                                                                                                                                                        (\ _lhsIfinKiVarMp
                                                                                                                                                                                                                                                                           _lhsIfinTyKiGam
                                                                                                                                                                                                                                                                           _lhsIpatClGam2
                                                                                                                                                                                                                                                                           _lhsItyTyTySigFreeTvarS ->
                                                                                                                                                                                                                                                                             _lhsIfinKiVarMp `seq`
                                                                                                                                                                                                                                                                             (_lhsIfinTyKiGam `seq`
                                                                                                                                                                                                                                                                              (_lhsIpatClGam2 `seq`
                                                                                                                                                                                                                                                                               (_lhsItyTyTySigFreeTvarS `seq`
                                                                                                                                                                                                                                                                                ((case (_lhsIpatClGam2) of
                                                                                                                                                                                                                                                                                  { _lhsOpatClGam2 | _lhsOpatClGam2 `seq` (True) ->
                                                                                                                                                                                                                                                                                  (case ((let sem_Decl_Default_10 :: T_Decl_10
                                                                                                                                                                                                                                                                                              sem_Decl_Default_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_Decl_Default_11 :: T_Decl_11
                                                                                                                                                                                                                                                                                                                         sem_Decl_Default_11 =
                                                                                                                                                                                                                                                                                                                             (\ _lhsIdataGam ->
                                                                                                                                                                                                                                                                                                                                  _lhsIdataGam `seq`
                                                                                                                                                                                                                                                                                                                                  ((case (Seq.empty) of
                                                                                                                                                                                                                                                                                                                                    { _lhsOchrClassDeclSq | _lhsOchrClassDeclSq `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                    (case (Seq.empty) of
                                                                                                                                                                                                                                                                                                                                     { _lhsOchrInstDeclSq | _lhsOchrInstDeclSq `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                     (case (gamSingleton nm_ (ClassDefaultGamInfo _tyExprsItyL)) of
                                                                                                                                                                                                                                                                                                                                      { _lhsOgathClDfGam | _lhsOgathClDfGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                      (case ((let sem_Decl_Default_12 :: T_Decl_12
                                                                                                                                                                                                                                                                                                                                                  sem_Decl_Default_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_Decl_Default_13 :: T_Decl_13
                                                                                                                                                                                                                                                                                                                                                                              sem_Decl_Default_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 (_tyExprsIintlTyKiGam) 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_Decl_Default_14 :: T_Decl_14
                                                                                                                                                                                                                                                                                                                                                                                                               sem_Decl_Default_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 (_lhsIvalTyGlobFreeTvarS) of
                                                                                                                                                                                                                                                                                                                                                                                                                                    { _tyExprsOvalTyGlobFreeTvarS | _tyExprsOvalTyGlobFreeTvarS `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                    (case (_lhsItyTyTySigFreeTvarS) of
                                                                                                                                                                                                                                                                                                                                                                                                                                     { _tyExprsOtyTyTySigFreeTvarS | _tyExprsOtyTyTySigFreeTvarS `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                     (case (_lhsItyTyGlobFreeTvarS) of
                                                                                                                                                                                                                                                                                                                                                                                                                                      { _tyExprsOtyTyGlobFreeTvarS | _tyExprsOtyTyGlobFreeTvarS `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                      (case (_lhsItyKiGlobFreeTvarS) of
                                                                                                                                                                                                                                                                                                                                                                                                                                       { _tyExprsOtyKiGlobFreeTvarS | _tyExprsOtyKiGlobFreeTvarS `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                       (case (_lhsItr) of
                                                                                                                                                                                                                                                                                                                                                                                                                                        { _tyExprsOtr | _tyExprsOtr `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                        (case (_lhsIsysfEnv) of
                                                                                                                                                                                                                                                                                                                                                                                                                                         { _tyExprsOsysfEnv | _tyExprsOsysfEnv `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                         (case (_lhsIopts) of
                                                                                                                                                                                                                                                                                                                                                                                                                                          { _tyExprsOopts | _tyExprsOopts `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                          (case (_lhsImoduleNm) of
                                                                                                                                                                                                                                                                                                                                                                                                                                           { _tyExprsOmoduleNm | _tyExprsOmoduleNm `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                           (case (_lhsIkiGam) of
                                                                                                                                                                                                                                                                                                                                                                                                                                            { _tyExprsOkiGam | _tyExprsOkiGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                            (case (_lhsIfinTyVarMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                             { _tyExprsOfinTyVarMp | _tyExprsOfinTyVarMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                             (case (_lhsIfinTyKiGam) of
                                                                                                                                                                                                                                                                                                                                                                                                                                              { _tyExprsOfinTyKiGam | _tyExprsOfinTyKiGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                              (case (_lhsIfinKiVarMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                               { _tyExprsOfinKiVarMp | _tyExprsOfinKiVarMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                               (case (_lhsIclGam) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                { _tyExprsOclGam | _tyExprsOclGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                (case (__tup61) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                 { (_,_lUniq_17_polCtx) | _lUniq_17_polCtx `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                 (case (mkPolVar _lUniq_17_polCtx) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                  { _tyExprsOknPolCtx | _tyExprsOknPolCtx `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                  (case (tyExprs_6 _tyExprsOclGam _tyExprsOfinKiVarMp _tyExprsOfinTyKiGam _tyExprsOfinTyVarMp _tyExprsOkiGam _tyExprsOknPolCtx _tyExprsOmoduleNm _tyExprsOopts _tyExprsOsysfEnv _tyExprsOtr _tyExprsOtyKiGlobFreeTvarS _tyExprsOtyTyGlobFreeTvarS _tyExprsOtyTyTySigFreeTvarS _tyExprsOvalTyGlobFreeTvarS) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                   { ( _tyExprsIallErrSq,_tyExprsIclMissNmS,_tyExprsIclNmS,_tyExprsIerrSq,_tyExprsIgathMentrelFilterMp,_tyExprsIpp,_tyExprsIppAST,_tyExprsIppL,_tyExprsItrpp) | True ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                       (case (_tyExprsIallErrSq) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                        { _lhsOallErrSq | _lhsOallErrSq `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                        (case ([]) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                         { _lhsObangEvalL | _lhsObangEvalL `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                         (case (_lhsIcSubst) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                          { _lhsOcSubst | _lhsOcSubst `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                          (case (_tyExprsIerrSq) 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 (mentrelFilterMpSingleton [_lhsImoduleNm] IdOcc_Type                   nm_
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      `mentrelFilterMpUnion`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      _tyExprsIgathMentrelFilterMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                { _gathMentrelFilterMp | _gathMentrelFilterMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                (case (_gathMentrelFilterMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                 { _lhsOgathMentrelFilterMp | _lhsOgathMentrelFilterMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                 (case (emptyVarMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  { _lhsOgathTvKiVarMp | _lhsOgathTvKiVarMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (case (Set.empty) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                   { _lhsOorphanS | _lhsOorphanS `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                   (case ("default"  >#< nm_ >#< ppParensCommas' _tyExprsIppL) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    { _pp | _pp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (case (_pp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                     { _lhsOpp | _lhsOpp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                     (case (trppEmpty) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      { _trppHere | _trppHere `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      (case (ppNestTrPP _lhsIopts ["Decl","Default"] [ppTrNm nm_] [_tyExprsIppAST] _trppHere) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                       { _ppAST | _ppAST `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                       (case (_ppAST) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        { _lhsOppAST | _lhsOppAST `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (case (_tyExprsItrpp) 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_Decl_Default_14)) of
                                                                                                                                                                                                                                                                                                                                                                                                    { ( sem_Decl_14) | True ->
                                                                                                                                                                                                                                                                                                                                                                                                    ( _lhsOgathCnstrMp,_lhsOgathRangeMp,_lhsOintlTyKiGam,_lhsOnoLetQuantTyVarIdS,_lhsOscopeGam,_lhsOtyVarMp,sem_Decl_14) }) }) }) }) }) }) }))))))))
                                                                                                                                                                                                                                                                                                                                                                          in  sem_Decl_Default_13)) of
                                                                                                                                                                                                                                                                                                                                                                   { ( sem_Decl_13) | True ->
                                                                                                                                                                                                                                                                                                                                                                   ( _lhsOpatTyVarMp,_lhsOpatValGam,sem_Decl_13) }) }) })))))))
                                                                                                                                                                                                                                                                                                                                              in  sem_Decl_Default_12)) of
                                                                                                                                                                                                                                                                                                                                       { ( sem_Decl_12) | True ->
                                                                                                                                                                                                                                                                                                                                       ( _lhsOchrClassDeclSq,_lhsOchrInstDeclSq,_lhsOgathClDfGam,sem_Decl_12) }) }) }) })))
                                                                                                                                                                                                                                                                                                                     in  sem_Decl_Default_11)) of
                                                                                                                                                                                                                                                                                                              { ( sem_Decl_11) | True ->
                                                                                                                                                                                                                                                                                                              ( _lhsOgathDataGam,_lhsOgathDeclDataGam,_lhsOgathTySigGam,_lhsOgathTySigVarMp,sem_Decl_11) }) }) }) }) }))))
                                                                                                                                                                                                                                                                                          in  sem_Decl_Default_10)) of
                                                                                                                                                                                                                                                                                   { ( sem_Decl_10) | True ->
                                                                                                                                                                                                                                                                                   ( _lhsOpatClGam2,sem_Decl_10) }) }))))))
                                                                                                                                                                                                                                                                in  sem_Decl_Default_9)) of
                                                                                                                                                                                                                                                         { ( sem_Decl_9) | True ->
                                                                                                                                                                                                                                                         ( _lhsOpatClGam1,sem_Decl_9) }) })))
                                                                                                                                                                                                                                         in  sem_Decl_Default_8)) of
                                                                                                                                                                                                                                  { ( sem_Decl_8) | True ->
                                                                                                                                                                                                                                  ( _lhsOgenerDataInfoL,_lhsOgenerDataInfoMp,_lhsOkiVarMp,_lhsOpolVarMp,sem_Decl_8) }) }) }) }) }) }) }) }) }) }) }) }) }) }))))))))))
                                                                                                                                                                               in  sem_Decl_Default_7)) of
                                                                                                                                                                        { ( sem_Decl_7) | True ->
                                                                                                                                                                        ( _lhsOpatKiVarMp,_lhsOpatPolGam,sem_Decl_7) }) }) })))))
                                                                                                                                                     in  sem_Decl_Default_6)) of
                                                                                                                                              { ( sem_Decl_6) | True ->
                                                                                                                                              ( _lhsOpatTyKiGam,_lhsOtyTyVarMp,sem_Decl_6) }) }) })))))
                                                                                                                           in  sem_Decl_Default_5)) of
                                                                                                                    { ( sem_Decl_5) | True ->
                                                                                                                    ( _lhsOpatTyGam,sem_Decl_5) }) }))))
                                                                                                   in  sem_Decl_Default_4)) of
                                                                                            { ( sem_Decl_4) | True ->
                                                                                            ( _lhsOpredSameScopeCounter,sem_Decl_4) }) }))))
                                                                           in  sem_Decl_Default_3)) of
                                                                    { ( sem_Decl_3) | True ->
                                                                    ( _lhsOgathTyKiSigGam,sem_Decl_3) }) })))
                                                    in  sem_Decl_Default_2)) of
                                             { ( sem_Decl_2) | True ->
                                             ( _lhsOgUniq,_lhsOgathKiSigGam,_lhsOhasInstDecl,sem_Decl_2) }) }) }) }) }) }) }))))
                   in  sem_Decl_Default_1)) of
            { ( sem_Decl_1) | True ->
            ( _lhsOrange,sem_Decl_1) }) }) }) })