packages feed

uhc-light-1.1.7.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.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.Base.Debug as Debug
import Debug.Trace
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.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.Light.Compiler.CHR
import UHC.Light.Compiler.CHR.Constraint
import UHC.Light.Compiler.Pred.CHR
import UHC.Light.Compiler.Pred.ToCHR
import UHC.Light.Compiler.Pred.Heuristics
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:
         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 Pred RedHowAnnotation)
         chrInstDeclSq        : Seq.FastSeq (CHRScopedInstanceDecl Pred RedHowAnnotation PredScope)
         gathClDfGam          : ClassDefaultGam
   visit 12:
      inherited attributes:
         tvKiVarMp            : VarMp
         tySigGam             : ValGam
         tySigVarMp           : VarMp
      chained attributes:
         patTyVarMp           : VarMp
         patValGam            : ValGam
   visit 13:
      inherited attributes:
         chrStore             : ScopedPredStore
         clDfGam              : ClassDefaultGam
         tyTyGlobFreeTvarS    : TyVarIdS
         valGam               : ValGam
         valTyGlobFreeTvarS   : TyVarIdS
      chained attribute:
         tyVarMp              : VarMp
      synthesized attributes:
         gathCnstrMp          : CHRPredOccCnstrMp
         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
      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
         tyCBindL             : CBindL
         valCBindL            : CBindL
   alternatives:
      alternative TySig:
         child hsrange        : {Range}
         child nm             : {HsName}
         child tyExpr         : TyExpr 
         visit 0:
            local range       : {Range}
         visit 1:
            local _tup21      : _
            intra range       : {Range}
         visit 2:
            intra _tup21      : _
            intra range       : {Range}
         visit 3:
            intra _tup21      : _
            intra range       : {Range}
         visit 4:
            intra _tup21      : _
            intra range       : {Range}
         visit 5:
            intra _tup21      : _
            intra range       : {Range}
         visit 6:
            intra _tup21      : _
            intra range       : {Range}
         visit 7:
            local lUniq_17_polCtx : {UID}
            local lUniq2      : {UID}
            local polCtxVar   : {Polarity}
            local fo_         : {FIOut}
            intra _tup21      : _
            intra range       : {Range}
         visit 8:
            intra _tup21      : _
            intra fo_         : {FIOut}
            intra range       : {Range}
         visit 9:
            intra _tup21      : _
            intra fo_         : {FIOut}
            intra range       : {Range}
         visit 10:
            local lUniq_sig   : {UID}
            local tyTyUpdFreeTvarS : _
            local gTyTvS      : {TyVarIdS}
            local ty_sig_     : {Ty}
            local gamSigTy    : _
            local _tup20      : _
            local gathTySigGam : _
            local gathTySigVarMp : _
            intra _tup21      : _
            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          : _
            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 _tup24      : _
            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 _tup23      : _
            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 _tup22      : _
            local chrScopeBindMp : _
            local finalTy     : _
            local fe          : {FIEnv}
            local finalTyExpanded : _
            local sysfty      : _
            local acorety     : _
            local pp          : _
            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 _tup26      : _
            intra range       : {Range}
         visit 2:
            intra _tup26      : _
            intra range       : {Range}
         visit 3:
            intra _tup26      : _
            intra range       : {Range}
         visit 4:
            local _tup25      : _
            local hasKiSig    : {Bool}
            local extraTyGam  : _
            local dataTgi     : _
            local dataPatTyGam : _
            intra _tup26      : _
            intra range       : {Range}
         visit 5:
            local lUniq       : {UID}
            local sigKi       : {Ty}
            local knKi        : {Ty}
            local extraTyKiGam : _
            local dataTkgi    : {TyKiGamInfo}
            local dataPatTyKiGam : _
            intra _tup26      : _
            intra _tup25      : _
            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 _tup26      : _
            intra dataTkgi    : {TyKiGamInfo}
            intra range       : {Range}
         visit 7:
            local dataTy      : {Ty}
            local dataAltTy   : {Ty}
            local dataTyVarIdL : {[TyVarId]}
            local dataKi      : {Ty}
            local lUniq3      : {UID}
            intra polCtxVar   : {Polarity}
            intra fo_         : {FIOut}
            intra _tup26      : _
            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 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 _tup27      : _
            intra range       : {Range}
         visit 2:
            intra _tup27      : _
            intra range       : {Range}
         visit 3:
            intra _tup27      : _
            intra range       : {Range}
         visit 4:
            intra _tup27      : _
            intra range       : {Range}
         visit 5:
            intra _tup27      : _
            intra range       : {Range}
         visit 6:
            intra _tup27      : _
            intra range       : {Range}
         visit 7:
            intra _tup27      : _
            intra range       : {Range}
         visit 8:
            intra _tup27      : _
            intra range       : {Range}
         visit 9:
            intra _tup27      : _
            intra range       : {Range}
         visit 10:
            local ty_sig_     : {Ty}
            intra _tup27      : _
            intra range       : {Range}
         visit 11:
            intra _tup27      : _
            intra range       : {Range}
            intra ty_sig_     : {Ty}
         visit 12:
            intra _tup27      : _
            intra range       : {Range}
            intra ty_sig_     : {Ty}
         visit 13:
            intra _tup27      : _
            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     : _
            intra _tup27      : _
            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 _tup30      : _
            intra range       : {Range}
         visit 2:
            intra _tup30      : _
            intra range       : {Range}
         visit 3:
            intra _tup30      : _
            intra range       : {Range}
         visit 4:
            local lUniq       : {UID}
            local typeVar     : _
            local typeTgi     : {TyGamInfo}
            intra _tup30      : _
            intra range       : {Range}
         visit 5:
            local _tup29      : _
            local sigKi       : {Ty}
            local knKi        : {Ty}
            local typeTkgi    : {TyKiGamInfo}
            local lUniq2      : {UID}
            local foTy_       : _
            intra lUniq       : {UID}
            intra _tup30      : _
            intra typeTgi     : {TyGamInfo}
            intra range       : {Range}
         visit 6:
            local lUniq_17_seed_pol : {UID}
            local _tup28      : _
            local polTypeVar  : {Polarity}
            local polSig      : {Polarity}
            intra _tup30      : _
            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 _tup28      : _
            intra typeTkgi    : {TyKiGamInfo}
            intra lUniq2      : {UID}
            intra _tup30      : _
            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 _tup32      : _
            intra range       : {Range}
         visit 2:
            intra _tup32      : _
            intra range       : {Range}
         visit 3:
            intra _tup32      : _
            intra range       : {Range}
         visit 4:
            intra _tup32      : _
            intra range       : {Range}
         visit 5:
            intra _tup32      : _
            intra range       : {Range}
         visit 6:
            intra _tup32      : _
            intra range       : {Range}
         visit 7:
            intra _tup32      : _
            intra range       : {Range}
         visit 8:
            intra _tup32      : _
            intra range       : {Range}
         visit 9:
            intra _tup32      : _
            intra range       : {Range}
         visit 10:
            local ty_sig_     : {Ty}
            intra _tup32      : _
            intra range       : {Range}
         visit 11:
            intra ty_sig_     : {Ty}
            intra _tup32      : _
            intra range       : {Range}
         visit 12:
            intra ty_sig_     : {Ty}
            intra _tup32      : _
            intra range       : {Range}
         visit 13:
            local knTy        : {Ty}
            local exprFiOpts  : {FIOpts}
            intra ty_sig_     : {Ty}
            intra _tup32      : _
            intra range       : {Range}
         visit 14:
            local lUniqFFE    : {UID}
            local rceEnv      : _
            local fe          : {FIEnv}
            local finalTyExpanded : _
            local _tup31      : _
            local ffeMkCExpr  : _
            local ffeCExpr    : _
            local ffeTy       : _
            local gathMentrelFilterMp : _
            local pp          : _
            intra _tup32      : _
            intra range       : {Range}
            intra ty_sig_     : {Ty}
      alternative GenerRep:
         child hsrange        : {Range}
         child maxArity       : {Int}
         child tyNm           : {HsName}
         child conNmL         : {[HsName]}
         child recFldNmL      : {[(HsName,[HsName])]}
         visit 0:
            local range       : {Range}
         visit 14:
            local pp          : _
      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 _tup33      : _
            intra range       : {Range}
         visit 2:
            intra _tup33      : _
            intra range       : {Range}
         visit 3:
            intra _tup33      : _
            intra range       : {Range}
         visit 4:
            intra _tup33      : _
            intra range       : {Range}
         visit 5:
            intra _tup33      : _
            intra range       : {Range}
         visit 6:
            intra _tup33      : _
            intra range       : {Range}
         visit 7:
            intra _tup33      : _
            intra range       : {Range}
         visit 8:
            intra _tup33      : _
            intra range       : {Range}
         visit 9:
            intra _tup33      : _
            intra range       : {Range}
         visit 10:
            intra _tup33      : _
            intra range       : {Range}
         visit 11:
            intra _tup33      : _
            intra range       : {Range}
         visit 12:
            intra _tup33      : _
            intra range       : {Range}
         visit 13:
            intra _tup33      : _
            intra range       : {Range}
         visit 14:
            local lUniq_buildInverse : {UID}
            local finAbsTy    : _
            local finConTy    : _
            local fe          : {FIEnv}
            local foBuildInverse : _
            local pp          : _
            intra _tup33      : _
            intra range       : {Range}
      alternative Class:
         child hsrange        : {Range}
         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 _tup36      : _
         visit 2:
            intra _tup36      : _
         visit 3:
            intra _tup36      : _
         visit 4:
            intra _tup36      : _
         visit 5:
            local lUniq       : {UID}
            local _tup35      : _
            local hdPrTy      : {Ty}
            local _tup34      : _
            local clsNm       : {HsName}
            intra _tup36      : _
         visit 6:
            local lUniq_17_polCtx : {UID}
            local polCtxVar   : {Polarity}
            local polSig      : {Polarity}
            intra _tup36      : _
            intra clsNm       : {HsName}
            intra lUniq       : {UID}
            intra hdPrTy      : {Ty}
            intra _tup35      : _
            intra _tup34      : _
         visit 7:
            local predScope   : {PredScope}
            intra polCtxVar   : {Polarity}
            intra lUniq       : {UID}
            intra clsNm       : {HsName}
            intra hdPrTy      : {Ty}
            intra _tup35      : _
            intra _tup34      : _
         visit 8:
            local clgi1       : {ClGamInfo}
            intra lUniq       : {UID}
            intra clsNm       : {HsName}
            intra hdPrTy      : {Ty}
            intra _tup35      : _
            intra _tup34      : _
         visit 9:
            local dataDictNm  : {HsName}
            local lSigGam     : _
            local clsTySigGam : {ValGam}
            local clsTySigDictGam : _
            local clsFldL     : {[Assoc HsName Ty]}
            local ctxtPrTyL   : {TyL}
            local supClsFldNmL : {[HsName]}
            local clsAllFldL  : {[Assoc HsName Ty]}
            local dataDictTag : {CTag}
            local dictTag     : {CTag}
            local clsTyRec    : {Ty}
            local clgi2       : {ClGamInfo}
            intra clsNm       : {HsName}
            intra hdPrTy      : {Ty}
            intra _tup35      : _
            intra clgi1       : {ClGamInfo}
            intra _tup34      : _
         visit 10:
            intra dataDictNm  : {HsName}
            intra clsAllFldL  : {[Assoc HsName Ty]}
            intra dataDictTag : {CTag}
            intra clsTyRec    : {Ty}
            intra clsTySigGam : {ValGam}
            intra supClsFldNmL : {[HsName]}
            intra ctxtPrTyL   : {TyL}
            intra dictTag     : {CTag}
            intra hdPrTy      : {Ty}
            intra _tup34      : _
            intra clsFldL     : {[Assoc HsName Ty]}
            intra clgi2       : {ClGamInfo}
         visit 11:
            local chrClassDecl : _
            intra supClsFldNmL : {[HsName]}
            intra ctxtPrTyL   : {TyL}
            intra dictTag     : {CTag}
            intra hdPrTy      : {Ty}
            intra clsTyRec    : {Ty}
            intra _tup34      : _
            intra dataDictNm  : {HsName}
            intra clsAllFldL  : {[Assoc HsName Ty]}
            intra clsFldL     : {[Assoc HsName Ty]}
            intra clgi2       : {ClGamInfo}
         visit 12:
            local clsArgTyL   : _
            local dataDictTy  : _
            local vgi         : _
            intra _tup34      : _
            intra dataDictNm  : {HsName}
            intra clsAllFldL  : {[Assoc HsName Ty]}
            intra hdPrTy      : {Ty}
            intra clsFldL     : {[Assoc HsName Ty]}
            intra clsTyRec    : {Ty}
            intra dictTag     : {CTag}
            intra clgi2       : {ClGamInfo}
         visit 13:
            intra hdPrTy      : {Ty}
            intra clsFldL     : {[Assoc HsName Ty]}
            intra dataDictTy  : _
            intra clsTyRec    : {Ty}
            intra dictTag     : {CTag}
            intra clgi2       : {ClGamInfo}
         visit 14:
            local clsTyArgs   : _
            local pp          : _
            intra hdPrTy      : {Ty}
            intra clsFldL     : {[Assoc HsName Ty]}
            intra dataDictTy  : _
            intra clsTyRec    : {Ty}
            intra dictTag     : {CTag}
            intra clgi2       : {ClGamInfo}
      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 _tup52      : _
            intra range       : {Range}
         visit 2:
            intra _tup52      : _
            intra range       : {Range}
         visit 3:
            intra _tup52      : _
            intra range       : {Range}
         visit 4:
            intra _tup52      : _
            intra range       : {Range}
         visit 5:
            intra _tup52      : _
            intra range       : {Range}
         visit 6:
            intra _tup52      : _
            intra range       : {Range}
         visit 7:
            local lUniq_17_polCtx : {UID}
            local predScope   : {PredScope}
            local mbKnPolCtx  : _
            intra _tup52      : _
            intra range       : {Range}
         visit 8:
            intra _tup52      : _
            intra range       : {Range}
            intra predScope   : {PredScope}
         visit 9:
            intra _tup52      : _
            intra range       : {Range}
            intra predScope   : {PredScope}
         visit 10:
            intra _tup52      : _
            intra range       : {Range}
            intra predScope   : {PredScope}
         visit 11:
            local lUniq_9_prTyFix : {UID}
            local lUniq       : {UID}
            local instId      : _
            local _tup49      : _
            local inclForElim : _
            local dictNm      : {HsName}
            local _tup46      : _
            local prTyFix     : {Ty}
            local _tup47      : _
            local hdPrTyFix   : {Ty}
            local ctxtPrTyFixL : {[Ty]}
            local unfixPrTyVarMp : {VarMp}
            local chrInstDecl : _
            intra _tup52      : _
            intra range       : {Range}
            intra predScope   : {PredScope}
         visit 12:
            local _tup48      : _
            local instClsNm   : _
            local dataDictNm  : {HsName}
            local instArgTyL  : _
            local dataDictTy  : _
            local ctxtPrFixL  : _
            local vgi         : _
            intra hdPrTyFix   : {Ty}
            intra ctxtPrTyFixL : {[Ty]}
            intra dictNm      : {HsName}
            intra _tup46      : _
            intra _tup52      : _
            intra range       : {Range}
            intra _tup47      : _
            intra predScope   : {PredScope}
            intra lUniq       : {UID}
         visit 13:
            local fixPrTyVarMp : {VarMp}
            local recTy       : {Ty}
            local recTyExts   : {AssocL HsName Ty}
            local tySigGam    : {ValGam}
            intra _tup46      : _
            intra _tup52      : _
            intra range       : {Range}
            intra instClsNm   : _
            intra _tup47      : _
            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 clgi        : {ClGamInfo}
            local derivTruncTailArity : {Int}
            local derivArity  : {Int}
            local derivDataTyNm : {HsName}
            local derivDataTyArgs : {TyL}
            local derivDataDGI : {DataGamInfo}
            local generForFitsInL : {[GenerForFitsIn]}
            local _tup37      : _
            local foGenerDeriv : _
            local tyVarMpDeclsL0 : {VarMp}
            local tyVarMpDeclsL01 : {VarMp}
            local doPredAmbigSplitForSimplify : _
            local fe2         : _
            local derivMp     : _
            local derivDataTGI : {TyGamInfo}
            local derivHdDataTy : {Ty}
            local derivErrs   : _
            local supPrTyL    : _
            local _tup50      : _
            local dictSelfNm  : _
            local dictBuildNm : _
            local derivHdPrTyCon : {Ty}
            local chrFIIn     : {FIIn}
            local _tup38      : _
            local chrSuperProveCnstrMp : _
            local chrCtxtAssumeCnstrMp : _
            local toProveSuperCnstrMp : _
            local chrProveFIIn : {FIIn}
            local _tup42      : _
            local chrSolveSuperRemCnstrMp : _
            local foGenerDerivL : _
            local generCnstrMp : _
            local _tup39      : _
            local toProveGathCnstrMp : _
            local chrInstAssumeCnstrMp : _
            local toProveDeclsCnstrMp : _
            local _tup40      : _
            local chrSolveDeclsRemCnstrMp : _
            local toAssumeNeverCnstrMp : _
            local cannotResSuperCnstrMp : _
            local cannotResDeclsCnstrMp : _
            local cannotProveCnstrMp : _
            local predNotPrfErrs : _
            local valNoSigErrs : _
            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 _tup45      : _
            local chrScopeDeclsBindL : _
            local chrSolveSuperScopeBindMp : _
            local _tup44      : _
            local chrScopeSuperBindL : _
            local derivDCL    : _
            local chrSuperProveNmL : _
            local chrCtxtArgNmL : _
            local _tup51      : _
            local cSubstInst  : _
            local chrSuperSimplifyResult : _
            local chrDeclsSimplifyResult : _
            local gathMentrelFilterMp : _
            local finalHdInstArgLExpanded : _
            local tyOrphanS   : _
            local clsOrphanS  : _
            local orphanS     : _
            local errDeclsPP  : _
            local errInstPP   : _
            local pp          : _
            intra _tup52      : _
            intra range       : {Range}
            intra instClsNm   : _
            intra _tup47      : _
            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 _tup54      : _
            intra range       : {Range}
         visit 2:
            intra _tup54      : _
            intra range       : {Range}
         visit 3:
            intra _tup54      : _
            intra range       : {Range}
         visit 4:
            intra _tup54      : _
            intra range       : {Range}
         visit 5:
            intra _tup54      : _
            intra range       : {Range}
         visit 6:
            intra _tup54      : _
            intra range       : {Range}
         visit 7:
            local lUniq_17_polCtx : {UID}
            intra _tup54      : _
            intra range       : {Range}
         visit 8:
            intra _tup54      : _
            intra range       : {Range}
         visit 9:
            intra _tup54      : _
            intra range       : {Range}
         visit 10:
            intra _tup54      : _
            intra range       : {Range}
         visit 11:
            local lUniq_9_prTyMeta : {UID}
            local lUniq       : {UID}
            local instId      : _
            local dictNm      : {HsName}
            local chrInstDecl : _
            intra _tup54      : _
            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          : _
            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 _tup55      : _
         visit 2:
            intra _tup55      : _
         visit 3:
            intra _tup55      : _
         visit 4:
            intra _tup55      : _
         visit 5:
            intra _tup55      : _
         visit 6:
            intra _tup55      : _
         visit 7:
            intra _tup55      : _
         visit 8:
            intra _tup55      : _
         visit 9:
            intra _tup55      : _
         visit 10:
            intra _tup55      : _
         visit 11:
            intra _tup55      : _
         visit 12:
            intra _tup55      : _
         visit 13:
            intra _tup55      : _
         visit 14:
            local lUniq_17_polCtx : {UID}
            local gathMentrelFilterMp : _
            local pp          : _
            intra _tup55      : _
-}
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
                                   { __tup21 | __tup21 `seq` (True) ->
                                   (case (__tup21) 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 =
                                                                                                                                                                                       (\ _lhsIkiVarMp
                                                                                                                                                                                          _lhsImbKnPolCtx
                                                                                                                                                                                          _lhsIopts
                                                                                                                                                                                          _lhsIpolGam
                                                                                                                                                                                          _lhsIpolVarMp
                                                                                                                                                                                          _lhsIpredScope
                                                                                                                                                                                          _lhsItyKiGlobFreeTvarS ->
                                                                                                                                                                                            _lhsIkiVarMp `seq`
                                                                                                                                                                                            (_lhsImbKnPolCtx `seq`
                                                                                                                                                                                             (_lhsIopts `seq`
                                                                                                                                                                                              (_lhsIpolGam `seq`
                                                                                                                                                                                               (_lhsIpolVarMp `seq`
                                                                                                                                                                                                (_lhsIpredScope `seq`
                                                                                                                                                                                                 (_lhsItyKiGlobFreeTvarS `seq`
                                                                                                                                                                                                  ((case ([]) of
                                                                                                                                                                                                    { _lhsOgenerDataInfoL | _lhsOgenerDataInfoL `seq` (True) ->
                                                                                                                                                                                                    (case (_lhsIpolVarMp) of
                                                                                                                                                                                                     { _tyExprOpolVarMp | _tyExprOpolVarMp `seq` (True) ->
                                                                                                                                                                                                     (case (_lhsIpolGam) of
                                                                                                                                                                                                      { _tyExprOpolGam | _tyExprOpolGam `seq` (True) ->
                                                                                                                                                                                                      (case (_lhsIkiVarMp) of
                                                                                                                                                                                                       { _tyExprOkiVarMp | _tyExprOkiVarMp `seq` (True) ->
                                                                                                                                                                                                       (case (__tup21) of
                                                                                                                                                                                                        { (_,_,_lUniq_17_polCtx,_) | _lUniq_17_polCtx `seq` (True) ->
                                                                                                                                                                                                        (case (__tup21) 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 (__tup21) 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
                                                                                                                                                                                                                                                                                                                                 tkg = gamUnion _lhsIfinTyKiGam _tyExprIintlTyKiGam
                                                                                                                                                                                                                                                                                                                                 t2k = tvarKi tkg _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
                                                                                                                                                                                                                                                                                                                         { __tup20 | __tup20 `seq` (True) ->
                                                                                                                                                                                                                                                                                                                         (case (__tup20) of
                                                                                                                                                                                                                                                                                                                          { (_gathTySigGam,_) | _gathTySigGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                          (case (_gathTySigGam) of
                                                                                                                                                                                                                                                                                                                           { _lhsOgathTySigGam | _lhsOgathTySigGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                           (case (__tup20) 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 ->
                                                                                                                                                                                                                                                                                                                                                                                                                                        _lhsIcSubst `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                                        (_lhsIchrEvidBindMp `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                                         (_lhsIchrScopeBindMp `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                                          (_lhsIfinTyVarMp `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                                           (_lhsIfinValGam `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                                            (_lhsIisStrict `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                                             (_lhsIkiSigGam `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                                              (_lhsImoduleNm `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                                               (_lhsIrangeMp `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                                                (_lhsIsysfEnv `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 (_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 _tyExprOtyKiGlobFreeTvarS _tyExprOtyTyGlobFreeTvarS _tyExprOtyTyTySigFreeTvarS _tyExprOvalTyGlobFreeTvarS) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    { ( _tyExprIallErrSq,_tyExprIappArgPPL,_tyExprIappFunNm,_tyExprIappFunPP,_tyExprIclMissNmS,_tyExprIclNmS,_tyExprIerrSq,_tyExprIgathMentrelFilterMp,_tyExprIpp,_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 ([]) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       { _lhsOtyCBindL | _lhsOtyCBindL `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       (case ([]) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        { _lhsOvalCBindL | _lhsOvalCBindL `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ( _lhsOallErrSq,_lhsObangEvalL,_lhsOcSubst,_lhsOerrSq,_lhsOffeCBindL,_lhsOffiCBindL,_lhsOgathHiddenExports,_lhsOgathLamMp,_lhsOgathMentrelFilterMp,_lhsOgathTvKiVarMp,_lhsOorphanS,_lhsOpp,_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,_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
                                        { __tup24 | __tup24 `seq` (True) ->
                                        (case (__tup24) 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 =
                                                                                                                                                                                                  (\ _lhsIkiVarMp
                                                                                                                                                                                                     _lhsImbKnPolCtx
                                                                                                                                                                                                     _lhsIopts
                                                                                                                                                                                                     _lhsIpolGam
                                                                                                                                                                                                     _lhsIpolVarMp
                                                                                                                                                                                                     _lhsIpredScope
                                                                                                                                                                                                     _lhsItyKiGlobFreeTvarS ->
                                                                                                                                                                                                       _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 (patExpr_2 _patExprOkiGam _patExprOlexLev _patExprOpredSameScopeCounter) of
                                                                                                                                                                                                                             { ( _patExprIpredSameScopeCounter,patExpr_3) | True ->
                                                                                                                                                                                                                                 (case (patExpr_3 _patExprOkiVarMp _patExprOopts _patExprOpolGam _patExprOpolVarMp _patExprOpredScope _patExprOtyGam _patExprOtyKiGam _patExprOtyKiGlobFreeTvarS) of
                                                                                                                                                                                                                                  { ( _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 (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 _exprOkiVarMp _exprOopts _exprOpolGam _exprOpolVarMp _exprOpredScope _exprOtyGam _exprOtyKiGam _exprOtyKiGlobFreeTvarS) of
                                                                                                                                                                                                                                                       { ( _exprIkiVarMp,_exprIpolVarMp,expr_4) | 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
                                                                                                                                                                                                                                                                                                                                                                                                                               { __tup23 | __tup23 `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                               (case (__tup23) of
                                                                                                                                                                                                                                                                                                                                                                                                                                { (_ty_sig_,_) | _ty_sig_ `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                (case (_ty_sig_) of
                                                                                                                                                                                                                                                                                                                                                                                                                                 { _knTy | _knTy `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                 (case (_knTy) of
                                                                                                                                                                                                                                                                                                                                                                                                                                  { _patExprOknTy | _patExprOknTy `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                  (case (__tup23) 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 ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             _lhsIcSubst `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             (_lhsIchrEvidBindMp `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              (_lhsIchrScopeBindMp `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               (_lhsIfinTyVarMp `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (_lhsIfinValGam `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 (_lhsIisStrict `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (_lhsIkiSigGam `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   (_lhsImoduleNm `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (_lhsIrangeMp `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     (_lhsIsysfEnv `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 (_lhsImoduleNm) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                { _exprOmoduleNm | _exprOmoduleNm `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (case (mkScopeBindings False _predScope _lhsIchrScopeBindMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 { __tup22 | __tup22 `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 (case (__tup22) 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 (_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 _patExprOtySigVarMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           { ( _patExprIallErrSq,_patExprIappArgPPL,_patExprIappFunNm,_patExprIappFunPP,_patExprIcSubst,_patExprIerrSq,_patExprIfsRPatL,_patExprIgathMentrelFilterMp,_patExprIgathTvKiVarMp,_patExprIisBang,_patExprIpatCRest,_patExprIpp,_patExprIrpat,_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) 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,_exprIorphanS,_exprIpp) | 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 ([]) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         { _lhsOtyCBindL | _lhsOtyCBindL `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         (case (__tup22) 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,_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,_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
                                        { __tup26 | __tup26 `seq` (True) ->
                                        (case (__tup26) 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
                                                                                                                              { __tup25 | __tup25 `seq` (True) ->
                                                                                                                              (case (__tup25) 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 (__tup26) of
                                                                                                                                                            { (_,_lUniq,_,_,_) | _lUniq `seq` (True) ->
                                                                                                                                                            (case (__tup25) 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 (__tup26) 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 (__tup26) 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 =
                                                                                                                                                                                                                              (\ _lhsIkiVarMp
                                                                                                                                                                                                                                 _lhsImbKnPolCtx
                                                                                                                                                                                                                                 _lhsIopts
                                                                                                                                                                                                                                 _lhsIpolGam
                                                                                                                                                                                                                                 _lhsIpolVarMp
                                                                                                                                                                                                                                 _lhsIpredScope
                                                                                                                                                                                                                                 _lhsItyKiGlobFreeTvarS ->
                                                                                                                                                                                                                                   _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 (__tup26) 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 [( (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_
                                                                                                                                                                                                                                                                                )]
                                                                                                                                                                                                                                                                          else []) of
                                                                                                                                                                                                                                                                    { _lhsOgenerDataInfoL | _lhsOgenerDataInfoL `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 ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _lhsIcSubst `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (_lhsIchrEvidBindMp `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                         (_lhsIchrScopeBindMp `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          (_lhsIfinTyVarMp `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                           (_lhsIfinValGam `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (_lhsIisStrict `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                             (_lhsIkiSigGam `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              (_lhsImoduleNm `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                               (_lhsIrangeMp `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (_lhsIsysfEnv `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 (_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 _constrsOtyKiGlobFreeTvarS _constrsOtyTyGlobFreeTvarS _constrsOtyTyTySigFreeTvarS _constrsOvalGam _constrsOvalTyGlobFreeTvarS) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       { ( _constrsIallErrSq,_constrsIerrSq,_constrsIffeCBindL,_constrsIffiCBindL,_constrsIgathMentrelFilterMp,_constrsIgathTvKiVarMp,_constrsIpp,_constrsIppL,_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 (_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 _tyVarsOtyKiGlobFreeTvarS _tyVarsOtyTyGlobFreeTvarS _tyVarsOtyTyTySigFreeTvarS _tyVarsOvalTyGlobFreeTvarS) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      { ( _tyVarsIallErrSq,_tyVarsIerrSq,_tyVarsIgathMentrelFilterMp,_tyVarsInmL,_tyVarsIpp,_tyVarsIppL) | 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 (_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,_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,_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 =
                                                                                                                                                                                             (\ _lhsIkiVarMp
                                                                                                                                                                                                _lhsImbKnPolCtx
                                                                                                                                                                                                _lhsIopts
                                                                                                                                                                                                _lhsIpolGam
                                                                                                                                                                                                _lhsIpolVarMp
                                                                                                                                                                                                _lhsIpredScope
                                                                                                                                                                                                _lhsItyKiGlobFreeTvarS ->
                                                                                                                                                                                                  _lhsIkiVarMp `seq`
                                                                                                                                                                                                  (_lhsImbKnPolCtx `seq`
                                                                                                                                                                                                   (_lhsIopts `seq`
                                                                                                                                                                                                    (_lhsIpolGam `seq`
                                                                                                                                                                                                     (_lhsIpolVarMp `seq`
                                                                                                                                                                                                      (_lhsIpredScope `seq`
                                                                                                                                                                                                       (_lhsItyKiGlobFreeTvarS `seq`
                                                                                                                                                                                                        ((case ([]) of
                                                                                                                                                                                                          { _lhsOgenerDataInfoL | _lhsOgenerDataInfoL `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 ->
                                                                                                                                                                                                                                                                                                                                                                                                   _lhsIcSubst `seq`
                                                                                                                                                                                                                                                                                                                                                                                                   (_lhsIchrEvidBindMp `seq`
                                                                                                                                                                                                                                                                                                                                                                                                    (_lhsIchrScopeBindMp `seq`
                                                                                                                                                                                                                                                                                                                                                                                                     (_lhsIfinTyVarMp `seq`
                                                                                                                                                                                                                                                                                                                                                                                                      (_lhsIfinValGam `seq`
                                                                                                                                                                                                                                                                                                                                                                                                       (_lhsIisStrict `seq`
                                                                                                                                                                                                                                                                                                                                                                                                        (_lhsIkiSigGam `seq`
                                                                                                                                                                                                                                                                                                                                                                                                         (_lhsImoduleNm `seq`
                                                                                                                                                                                                                                                                                                                                                                                                          (_lhsIrangeMp `seq`
                                                                                                                                                                                                                                                                                                                                                                                                           (_lhsIsysfEnv `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 (_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 _kiExprOtyKiGlobFreeTvarS _kiExprOtyTyGlobFreeTvarS _kiExprOtyTyTySigFreeTvarS _kiExprOvalTyGlobFreeTvarS) of
                                                                                                                                                                                                                                                                                                                                                                                                                        { ( _kiExprIallErrSq,_kiExprIappArgPPL,_kiExprIappFunNm,_kiExprIappFunPP,_kiExprIerrSq,_kiExprIgathMentrelFilterMp,_kiExprIpp) | 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 ([]) of
                                                                                                                                                                                                                                                                                                                                                                                                                                          { _lhsOtyCBindL | _lhsOtyCBindL `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                          (case ([]) of
                                                                                                                                                                                                                                                                                                                                                                                                                                           { _lhsOvalCBindL | _lhsOvalCBindL `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                           ( _lhsOallErrSq,_lhsObangEvalL,_lhsOcSubst,_lhsOerrSq,_lhsOffeCBindL,_lhsOffiCBindL,_lhsOgathHiddenExports,_lhsOgathLamMp,_lhsOgathMentrelFilterMp,_lhsOgathTvKiVarMp,_lhsOorphanS,_lhsOpp,_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,_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
                                   { __tup27 | __tup27 `seq` (True) ->
                                   (case (__tup27) 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 =
                                                                                                                                                                                       (\ _lhsIkiVarMp
                                                                                                                                                                                          _lhsImbKnPolCtx
                                                                                                                                                                                          _lhsIopts
                                                                                                                                                                                          _lhsIpolGam
                                                                                                                                                                                          _lhsIpolVarMp
                                                                                                                                                                                          _lhsIpredScope
                                                                                                                                                                                          _lhsItyKiGlobFreeTvarS ->
                                                                                                                                                                                            _lhsIkiVarMp `seq`
                                                                                                                                                                                            (_lhsImbKnPolCtx `seq`
                                                                                                                                                                                             (_lhsIopts `seq`
                                                                                                                                                                                              (_lhsIpolGam `seq`
                                                                                                                                                                                               (_lhsIpolVarMp `seq`
                                                                                                                                                                                                (_lhsIpredScope `seq`
                                                                                                                                                                                                 (_lhsItyKiGlobFreeTvarS `seq`
                                                                                                                                                                                                  ((case ([]) of
                                                                                                                                                                                                    { _lhsOgenerDataInfoL | _lhsOgenerDataInfoL `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
                                                                                                                                                                                                                                                                                                                          tkg = gamUnion _lhsIfinTyKiGam _tyExprIintlTyKiGam
                                                                                                                                                                                                                                                                                                                          t2k = tvarKi tkg _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 ->
                                                                                                                                                                                                                                                                                                                                                                                                                             _lhsIcSubst `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                             (_lhsIchrEvidBindMp `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                              (_lhsIchrScopeBindMp `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                               (_lhsIfinTyVarMp `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                                (_lhsIfinValGam `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                                 (_lhsIisStrict `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                                  (_lhsIkiSigGam `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                                   (_lhsImoduleNm `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                                    (_lhsIrangeMp `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                                     (_lhsIsysfEnv `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 (_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 _tyExprOtyKiGlobFreeTvarS _tyExprOtyTyGlobFreeTvarS _tyExprOtyTyTySigFreeTvarS _tyExprOvalTyGlobFreeTvarS) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                         { ( _tyExprIallErrSq,_tyExprIappArgPPL,_tyExprIappFunNm,_tyExprIappFunPP,_tyExprIclMissNmS,_tyExprIclNmS,_tyExprIerrSq,_tyExprIgathMentrelFilterMp,_tyExprIpp,_tyExprItyWildL) | True ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                             (case (_tyExprIallErrSq) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                              { _lhsOallErrSq | _lhsOallErrSq `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                              (case ([]) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                               { _lhsObangEvalL | _lhsObangEvalL `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                               (case (_lhsIcSubst) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                { _lhsOcSubst | _lhsOcSubst `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                (case (__tup27) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                 { (_,_,_,_lUniq3,_) | _lUniq3 `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                 (case (__tup27) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  { (_,_,_lUniq2,_,_) | _lUniq2 `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (case (__tup27) 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 (__tup27) 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 ([]) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       { _lhsOtyCBindL | _lhsOtyCBindL `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       (case ([]) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        { _lhsOvalCBindL | _lhsOvalCBindL `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ( _lhsOallErrSq,_lhsObangEvalL,_lhsOcSubst,_lhsOerrSq,_lhsOffeCBindL,_lhsOffiCBindL,_lhsOgathHiddenExports,_lhsOgathLamMp,_lhsOgathMentrelFilterMp,_lhsOgathTvKiVarMp,_lhsOorphanS,_lhsOpp,_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,_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
                                   { __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_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 (__tup30) 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
                                                                                                                                               { __tup29 | __tup29 `seq` (True) ->
                                                                                                                                               (case (__tup29) 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 (__tup30) 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 (__tup30) 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
                                                                                                                                                                                       { __tup28 | __tup28 `seq` (True) ->
                                                                                                                                                                                       (case (__tup28) 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 =
                                                                                                                                                                                                          (\ _lhsIkiVarMp
                                                                                                                                                                                                             _lhsImbKnPolCtx
                                                                                                                                                                                                             _lhsIopts
                                                                                                                                                                                                             _lhsIpolGam
                                                                                                                                                                                                             _lhsIpolVarMp
                                                                                                                                                                                                             _lhsIpredScope
                                                                                                                                                                                                             _lhsItyKiGlobFreeTvarS ->
                                                                                                                                                                                                               _lhsIkiVarMp `seq`
                                                                                                                                                                                                               (_lhsImbKnPolCtx `seq`
                                                                                                                                                                                                                (_lhsIopts `seq`
                                                                                                                                                                                                                 (_lhsIpolGam `seq`
                                                                                                                                                                                                                  (_lhsIpolVarMp `seq`
                                                                                                                                                                                                                   (_lhsIpredScope `seq`
                                                                                                                                                                                                                    (_lhsItyKiGlobFreeTvarS `seq`
                                                                                                                                                                                                                     ((case ([]) of
                                                                                                                                                                                                                       { _lhsOgenerDataInfoL | _lhsOgenerDataInfoL `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 (__tup28) 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 (__tup30) 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 ->
                                                                                                                                                                                                                                                                                                                                                                                                                                             _lhsIcSubst `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                                             (_lhsIchrEvidBindMp `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                                              (_lhsIchrScopeBindMp `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                                               (_lhsIfinTyVarMp `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                                                (_lhsIfinValGam `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                                                 (_lhsIisStrict `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                                                  (_lhsIkiSigGam `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                                                   (_lhsImoduleNm `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                                                    (_lhsIrangeMp `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                                                     (_lhsIsysfEnv `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 (_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 _tyExprOtyKiGlobFreeTvarS _tyExprOtyTyGlobFreeTvarS _tyExprOtyTyTySigFreeTvarS _tyExprOvalTyGlobFreeTvarS) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                         { ( _tyExprIallErrSq,_tyExprIappArgPPL,_tyExprIappFunNm,_tyExprIappFunPP,_tyExprIclMissNmS,_tyExprIclNmS,_tyExprIerrSq,_tyExprIgathMentrelFilterMp,_tyExprIpp,_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 ([]) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           { _lhsOtyCBindL | _lhsOtyCBindL `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           (case ([]) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            { _lhsOvalCBindL | _lhsOvalCBindL `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ( _lhsOallErrSq,_lhsObangEvalL,_lhsOcSubst,_lhsOerrSq,_lhsOffeCBindL,_lhsOffiCBindL,_lhsOgathHiddenExports,_lhsOgathLamMp,_lhsOgathMentrelFilterMp,_lhsOgathTvKiVarMp,_lhsOorphanS,_lhsOpp,_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,_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
                                        { __tup32 | __tup32 `seq` (True) ->
                                        (case (__tup32) 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 =
                                                                                                                                                                                                           (\ _lhsIkiVarMp
                                                                                                                                                                                                              _lhsImbKnPolCtx
                                                                                                                                                                                                              _lhsIopts
                                                                                                                                                                                                              _lhsIpolGam
                                                                                                                                                                                                              _lhsIpolVarMp
                                                                                                                                                                                                              _lhsIpredScope
                                                                                                                                                                                                              _lhsItyKiGlobFreeTvarS ->
                                                                                                                                                                                                                _lhsIkiVarMp `seq`
                                                                                                                                                                                                                (_lhsImbKnPolCtx `seq`
                                                                                                                                                                                                                 (_lhsIopts `seq`
                                                                                                                                                                                                                  (_lhsIpolGam `seq`
                                                                                                                                                                                                                   (_lhsIpolVarMp `seq`
                                                                                                                                                                                                                    (_lhsIpredScope `seq`
                                                                                                                                                                                                                     (_lhsItyKiGlobFreeTvarS `seq`
                                                                                                                                                                                                                      ((case ([]) of
                                                                                                                                                                                                                        { _lhsOgenerDataInfoL | _lhsOgenerDataInfoL `seq` (True) ->
                                                                                                                                                                                                                        (case (_lhsItyKiGam) of
                                                                                                                                                                                                                         { _tyExprOtyKiGam | _tyExprOtyKiGam `seq` (True) ->
                                                                                                                                                                                                                         (case (_lhsItyGam) of
                                                                                                                                                                                                                          { _tyExprOtyGam | _tyExprOtyGam `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 (expr_3 _exprOkiVarMp _exprOopts _exprOpolGam _exprOpolVarMp _exprOpredScope _exprOtyGam _exprOtyKiGam _exprOtyKiGlobFreeTvarS) of
                                                                                                                                                                                                                                   { ( _exprIkiVarMp,_exprIpolVarMp,expr_4) | 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
                                                                                                                                                                                                                                                                                                                                                                     tkg = gamUnion _lhsIfinTyKiGam _tyExprIintlTyKiGam
                                                                                                                                                                                                                                                                                                                                                                     t2k = tvarKi tkg _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 ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              _lhsIcSubst `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              (_lhsIchrEvidBindMp `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               (_lhsIchrScopeBindMp `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (_lhsIfinTyVarMp `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 (_lhsIfinValGam `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (_lhsIisStrict `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   (_lhsIkiSigGam `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (_lhsImoduleNm `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     (_lhsIrangeMp `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      (_lhsIsysfEnv `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 (_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 _tyExprOtyKiGlobFreeTvarS _tyExprOtyTyGlobFreeTvarS _tyExprOtyTyTySigFreeTvarS _tyExprOvalTyGlobFreeTvarS) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              { ( _tyExprIallErrSq,_tyExprIappArgPPL,_tyExprIappFunNm,_tyExprIappFunPP,_tyExprIclMissNmS,_tyExprIclNmS,_tyExprIerrSq,_tyExprIgathMentrelFilterMp,_tyExprIpp,_tyExprItyWildL) | 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) 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,_exprIorphanS,_exprIpp) | 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 (__tup32) 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
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     { __tup31 | __tup31 `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     (case (__tup31) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      { (_ffeMkCExpr,_) | _ffeMkCExpr `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      (case (_ffeMkCExpr _exprIcexpr) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       { _ffeCExpr | _ffeCExpr `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       (case (__tup31) 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 ([]) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   { _lhsOtyCBindL | _lhsOtyCBindL `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   (case ([]) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    { _lhsOvalCBindL | _lhsOvalCBindL `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ( _lhsOallErrSq,_lhsObangEvalL,_lhsOcSubst,_lhsOerrSq,_lhsOffeCBindL,_lhsOffiCBindL,_lhsOgathHiddenExports,_lhsOgathLamMp,_lhsOgathMentrelFilterMp,_lhsOgathTvKiVarMp,_lhsOorphanS,_lhsOpp,_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,_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 ->
                     HsName ->
                     ([HsName]) ->
                     ([(HsName,[HsName])]) ->
                     T_Decl

sem_Decl_GenerRep hsrange_ maxArity_ tyNm_ conNmL_ recFldNmL_ | hsrange_ `seq` (maxArity_ `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 =
                                                                                                                                                                           (\ _lhsIkiVarMp
                                                                                                                                                                              _lhsImbKnPolCtx
                                                                                                                                                                              _lhsIopts
                                                                                                                                                                              _lhsIpolGam
                                                                                                                                                                              _lhsIpolVarMp
                                                                                                                                                                              _lhsIpredScope
                                                                                                                                                                              _lhsItyKiGlobFreeTvarS ->
                                                                                                                                                                                _lhsIkiVarMp `seq`
                                                                                                                                                                                (_lhsImbKnPolCtx `seq`
                                                                                                                                                                                 (_lhsIopts `seq`
                                                                                                                                                                                  (_lhsIpolGam `seq`
                                                                                                                                                                                   (_lhsIpolVarMp `seq`
                                                                                                                                                                                    (_lhsIpredScope `seq`
                                                                                                                                                                                     (_lhsItyKiGlobFreeTvarS `seq`
                                                                                                                                                                                      ((case ([]) of
                                                                                                                                                                                        { _lhsOgenerDataInfoL | _lhsOgenerDataInfoL `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 ->
                                                                                                                                                                                                                                                                                                                                                                                 _lhsIcSubst `seq`
                                                                                                                                                                                                                                                                                                                                                                                 (_lhsIchrEvidBindMp `seq`
                                                                                                                                                                                                                                                                                                                                                                                  (_lhsIchrScopeBindMp `seq`
                                                                                                                                                                                                                                                                                                                                                                                   (_lhsIfinTyVarMp `seq`
                                                                                                                                                                                                                                                                                                                                                                                    (_lhsIfinValGam `seq`
                                                                                                                                                                                                                                                                                                                                                                                     (_lhsIisStrict `seq`
                                                                                                                                                                                                                                                                                                                                                                                      (_lhsIkiSigGam `seq`
                                                                                                                                                                                                                                                                                                                                                                                       (_lhsImoduleNm `seq`
                                                                                                                                                                                                                                                                                                                                                                                        (_lhsIrangeMp `seq`
                                                                                                                                                                                                                                                                                                                                                                                         (_lhsIsysfEnv `seq`
                                                                                                                                                                                                                                                                                                                                                                                          ((case (Seq.empty) of
                                                                                                                                                                                                                                                                                                                                                                                            { _lhsOallErrSq | _lhsOallErrSq `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                            (case ([]) of
                                                                                                                                                                                                                                                                                                                                                                                             { _lhsObangEvalL | _lhsObangEvalL `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                             (case (_lhsIcSubst) of
                                                                                                                                                                                                                                                                                                                                                                                              { _lhsOcSubst | _lhsOcSubst `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                              (case (Seq.empty) of
                                                                                                                                                                                                                                                                                                                                                                                               { _lhsOerrSq | _lhsOerrSq `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                               (case ([]) of
                                                                                                                                                                                                                                                                                                                                                                                                { _lhsOffeCBindL | _lhsOffeCBindL `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                (case ([]) of
                                                                                                                                                                                                                                                                                                                                                                                                 { _lhsOffiCBindL | _lhsOffiCBindL `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                 (case (Seq.empty) of
                                                                                                                                                                                                                                                                                                                                                                                                  { _lhsOgathHiddenExports | _lhsOgathHiddenExports `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                  (case (Map.empty) of
                                                                                                                                                                                                                                                                                                                                                                                                   { _lhsOgathLamMp | _lhsOgathLamMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                   (case (Map.empty) of
                                                                                                                                                                                                                                                                                                                                                                                                    { _lhsOgathMentrelFilterMp | _lhsOgathMentrelFilterMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                    (case (emptyVarMp) of
                                                                                                                                                                                                                                                                                                                                                                                                     { _lhsOgathTvKiVarMp | _lhsOgathTvKiVarMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                     (case (Set.empty) of
                                                                                                                                                                                                                                                                                                                                                                                                      { _lhsOorphanS | _lhsOorphanS `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                      (case ("generic" >#< (maxArity_ >#< tyNm_ >-< (vlist conNmL_) >-< (ppAssocLV $ assocLMapElt ppCurlysCommas recFldNmL_))) of
                                                                                                                                                                                                                                                                                                                                                                                                       { _pp | _pp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                       (case (_pp) of
                                                                                                                                                                                                                                                                                                                                                                                                        { _lhsOpp | _lhsOpp `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,_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,_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 =
                                                                                                                                                                           (\ _lhsIkiVarMp
                                                                                                                                                                              _lhsImbKnPolCtx
                                                                                                                                                                              _lhsIopts
                                                                                                                                                                              _lhsIpolGam
                                                                                                                                                                              _lhsIpolVarMp
                                                                                                                                                                              _lhsIpredScope
                                                                                                                                                                              _lhsItyKiGlobFreeTvarS ->
                                                                                                                                                                                _lhsIkiVarMp `seq`
                                                                                                                                                                                (_lhsImbKnPolCtx `seq`
                                                                                                                                                                                 (_lhsIopts `seq`
                                                                                                                                                                                  (_lhsIpolGam `seq`
                                                                                                                                                                                   (_lhsIpolVarMp `seq`
                                                                                                                                                                                    (_lhsIpredScope `seq`
                                                                                                                                                                                     (_lhsItyKiGlobFreeTvarS `seq`
                                                                                                                                                                                      ((case ([]) of
                                                                                                                                                                                        { _lhsOgenerDataInfoL | _lhsOgenerDataInfoL `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 ->
                                                                                                                                                                                                                                                                                                                                                                                 _lhsIcSubst `seq`
                                                                                                                                                                                                                                                                                                                                                                                 (_lhsIchrEvidBindMp `seq`
                                                                                                                                                                                                                                                                                                                                                                                  (_lhsIchrScopeBindMp `seq`
                                                                                                                                                                                                                                                                                                                                                                                   (_lhsIfinTyVarMp `seq`
                                                                                                                                                                                                                                                                                                                                                                                    (_lhsIfinValGam `seq`
                                                                                                                                                                                                                                                                                                                                                                                     (_lhsIisStrict `seq`
                                                                                                                                                                                                                                                                                                                                                                                      (_lhsIkiSigGam `seq`
                                                                                                                                                                                                                                                                                                                                                                                       (_lhsImoduleNm `seq`
                                                                                                                                                                                                                                                                                                                                                                                        (_lhsIrangeMp `seq`
                                                                                                                                                                                                                                                                                                                                                                                         (_lhsIsysfEnv `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 ([]) of
                                                                                                                                                                                                                                                                                                                                                                                                         { _lhsOtyCBindL | _lhsOtyCBindL `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                         (case ([]) of
                                                                                                                                                                                                                                                                                                                                                                                                          { _lhsOvalCBindL | _lhsOvalCBindL `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                          ( _lhsOallErrSq,_lhsObangEvalL,_lhsOcSubst,_lhsOerrSq,_lhsOffeCBindL,_lhsOffiCBindL,_lhsOgathHiddenExports,_lhsOgathLamMp,_lhsOgathMentrelFilterMp,_lhsOgathTvKiVarMp,_lhsOorphanS,_lhsOpp,_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,_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
                              { __tup33 | __tup33 `seq` (True) ->
                              (case (__tup33) 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 =
                                                                                                                                                                            (\ _lhsIkiVarMp
                                                                                                                                                                               _lhsImbKnPolCtx
                                                                                                                                                                               _lhsIopts
                                                                                                                                                                               _lhsIpolGam
                                                                                                                                                                               _lhsIpolVarMp
                                                                                                                                                                               _lhsIpredScope
                                                                                                                                                                               _lhsItyKiGlobFreeTvarS ->
                                                                                                                                                                                 _lhsIkiVarMp `seq`
                                                                                                                                                                                 (_lhsImbKnPolCtx `seq`
                                                                                                                                                                                  (_lhsIopts `seq`
                                                                                                                                                                                   (_lhsIpolGam `seq`
                                                                                                                                                                                    (_lhsIpolVarMp `seq`
                                                                                                                                                                                     (_lhsIpredScope `seq`
                                                                                                                                                                                      (_lhsItyKiGlobFreeTvarS `seq`
                                                                                                                                                                                       ((case ([]) of
                                                                                                                                                                                         { _lhsOgenerDataInfoL | _lhsOgenerDataInfoL `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 ->
                                                                                                                                                                                                                                                                                                                                                                                  _lhsIcSubst `seq`
                                                                                                                                                                                                                                                                                                                                                                                  (_lhsIchrEvidBindMp `seq`
                                                                                                                                                                                                                                                                                                                                                                                   (_lhsIchrScopeBindMp `seq`
                                                                                                                                                                                                                                                                                                                                                                                    (_lhsIfinTyVarMp `seq`
                                                                                                                                                                                                                                                                                                                                                                                     (_lhsIfinValGam `seq`
                                                                                                                                                                                                                                                                                                                                                                                      (_lhsIisStrict `seq`
                                                                                                                                                                                                                                                                                                                                                                                       (_lhsIkiSigGam `seq`
                                                                                                                                                                                                                                                                                                                                                                                        (_lhsImoduleNm `seq`
                                                                                                                                                                                                                                                                                                                                                                                         (_lhsIrangeMp `seq`
                                                                                                                                                                                                                                                                                                                                                                                          (_lhsIsysfEnv `seq`
                                                                                                                                                                                                                                                                                                                                                                                           ((case (Seq.empty) of
                                                                                                                                                                                                                                                                                                                                                                                             { _lhsOallErrSq | _lhsOallErrSq `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                             (case ([]) of
                                                                                                                                                                                                                                                                                                                                                                                              { _lhsObangEvalL | _lhsObangEvalL `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                              (case (_lhsIcSubst) of
                                                                                                                                                                                                                                                                                                                                                                                               { _lhsOcSubst | _lhsOcSubst `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                               (case (__tup33) 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 ([]) of
                                                                                                                                                                                                                                                                                                                                                                                                               { _lhsOtyCBindL | _lhsOtyCBindL `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                               (case ([]) of
                                                                                                                                                                                                                                                                                                                                                                                                                { _lhsOvalCBindL | _lhsOvalCBindL `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                ( _lhsOallErrSq,_lhsObangEvalL,_lhsOcSubst,_lhsOerrSq,_lhsOffeCBindL,_lhsOffiCBindL,_lhsOgathHiddenExports,_lhsOgathLamMp,_lhsOgathMentrelFilterMp,_lhsOgathTvKiVarMp,_lhsOorphanS,_lhsOpp,_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,_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 ->
                  T_TyExpr ->
                  T_FuncDeps ->
                  (Maybe HsName) ->
                  T_Decls ->
                  ([(HsName,HsName)]) ->
                  T_Decl

sem_Decl_Class hsrange_ tyPrExpr_ funcDeps_ mbDefaultInstNm_ decls_ generDerivs_ | hsrange_ `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
                                        { __tup36 | __tup36 `seq` (True) ->
                                        (case (__tup36) 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 (_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 (__tup36) of
                                                                                                                                                                    { (_,_lUniq,_,_) | _lUniq `seq` (True) ->
                                                                                                                                                                    (case (gamPushNew _lhsItyGam) of
                                                                                                                                                                     { _tyPrExprOtyGam | _tyPrExprOtyGam `seq` (True) ->
                                                                                                                                                                     (case (tyPrExpr_2 _tyPrExprOtyGam) of
                                                                                                                                                                      { ( _tyPrExprIty,_tyPrExprItyGam,tyPrExpr_3) | True ->
                                                                                                                                                                          (case (appUnArr _tyPrExprIty) of
                                                                                                                                                                           { __tup35 | __tup35 `seq` (True) ->
                                                                                                                                                                           (case (__tup35) of
                                                                                                                                                                            { (_,_hdPrTy) | _hdPrTy `seq` (True) ->
                                                                                                                                                                            (case (tyPredMatchNmArgs _hdPrTy) of
                                                                                                                                                                             { __tup34 | __tup34 `seq` (True) ->
                                                                                                                                                                             (case (__tup34) of
                                                                                                                                                                              { (_clsNm,_) | _clsNm `seq` (True) ->
                                                                                                                                                                              (case (tyKiGamNameSingleton (hsnClass2Kind _clsNm) (TyKiGamInfo $ mkNewTyVar _lUniq) `gamUnion` _lhsIpatTyKiGam) of
                                                                                                                                                                               { _lhsOpatTyKiGam | _lhsOpatTyKiGam `seq` (True) ->
                                                                                                                                                                               (case (_lhsItyTyVarMp) of
                                                                                                                                                                                { _declsOtyTyVarMp | _declsOtyTyVarMp `seq` (True) ->
                                                                                                                                                                                (case (_lhsItyKiSigGam) of
                                                                                                                                                                                 { _declsOtyKiSigGam | _declsOtyKiSigGam `seq` (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 (__tup36) of
                                                                                                                                                                                                                                      { (_,_,_lUniq_17_polCtx,_) | _lUniq_17_polCtx `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 _clsNm) (mkPGI _polSig) _lhsIpatPolGam) of
                                                                                                                                                                                                                                               { _lhsOpatPolGam | _lhsOpatPolGam `seq` (True) ->
                                                                                                                                                                                                                                               (case ((let sem_Decl_Class_7 :: T_Decl_7
                                                                                                                                                                                                                                                           sem_Decl_Class_7 =
                                                                                                                                                                                                                                                               (\ _lhsIkiVarMp
                                                                                                                                                                                                                                                                  _lhsImbKnPolCtx
                                                                                                                                                                                                                                                                  _lhsIopts
                                                                                                                                                                                                                                                                  _lhsIpolGam
                                                                                                                                                                                                                                                                  _lhsIpolVarMp
                                                                                                                                                                                                                                                                  _lhsIpredScope
                                                                                                                                                                                                                                                                  _lhsItyKiGlobFreeTvarS ->
                                                                                                                                                                                                                                                                    _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 (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 _declsOkiVarMp _declsOmbKnPolCtx _declsOopts _declsOpolGam _declsOpolVarMp _declsOpredScope _declsOtyKiGlobFreeTvarS) of
                                                                                                                                                                                                                                                                                                                     { ( _declsIgenerDataInfoL,_declsIkiVarMp,_declsIpolVarMp,decls_8) | True ->
                                                                                                                                                                                                                                                                                                                         (case (_declsIgenerDataInfoL) of
                                                                                                                                                                                                                                                                                                                          { _lhsOgenerDataInfoL | _lhsOgenerDataInfoL `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 _clsNm _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 (hsnClass2Dict _clsNm) of
                                                                                                                                                                                                                                                                                                                                                                                   { _dataDictNm | _dataDictNm `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 (assocLMapElt vgiTy (gamToAssocL _clsTySigDictGam)) of
                                                                                                                                                                                                                                                                                                                                                                                                        { _clsFldL | _clsFldL `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                        (case (__tup35) of
                                                                                                                                                                                                                                                                                                                                                                                                         { (_ctxtPrTyL,_) | _ctxtPrTyL `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                         (case (tyPrLToSupNmL _ctxtPrTyL) of
                                                                                                                                                                                                                                                                                                                                                                                                          { _supClsFldNmL | _supClsFldNmL `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                          (case (_clsFldL ++ zip _supClsFldNmL (repeat Ty_Any)) of
                                                                                                                                                                                                                                                                                                                                                                                                           { _clsAllFldL | _clsAllFldL `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                           (case (mkClassCTag _dataDictNm (length _clsAllFldL)) of
                                                                                                                                                                                                                                                                                                                                                                                                            { _dataDictTag | _dataDictTag `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                            (case (if ehcCfgClassViaRec _lhsIopts then CTagRec else _dataDictTag) of
                                                                                                                                                                                                                                                                                                                                                                                                             { _dictTag | _dictTag `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                             (case (recRec _clsAllFldL) of
                                                                                                                                                                                                                                                                                                                                                                                                              { _clsTyRec | _clsTyRec `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                              (case (_clgi1 { clgiPrToEvidTy     = tyQuantifyClosed $ [_hdPrTy] `appArr` _clsTyRec
                                                                                                                                                                                                                                                                                                                                                                                                                            , clgiRuleTy         = tyQuantifyClosed _tyPrExprIty
                                                                                                                                                                                                                                                                                                                                                                                                                            , clgiDictTag        = _dictTag
                                                                                                                                                                                                                                                                                                                                                                                                                            }) of
                                                                                                                                                                                                                                                                                                                                                                                                               { _clgi2 | _clgi2 `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                               (case (gamAdd _clsNm _clgi2 _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 (if ehcCfgClassViaRec _lhsIopts
                                                                                                                                                                                                                                                                                                                                                                                                                                               then emptyGam
                                                                                                                                                                                                                                                                                                                                                                                                                                               else let dgi = mkDGIPlain _dataDictNm _clsTyRec (appDbg $ "Decl.Class.dgi: " ++ show _dataDictNm) [_dataDictNm] (_dataDictNm `Map.singleton` dti)
                                                                                                                                                                                                                                                                                                                                                                                                                                                        dti = emptyDataTagInfo
                                                                                                                                                                                                                                                                                                                                                                                                                                                                { dtiCTag = _dataDictTag
                                                                                                                                                                                                                                                                                                                                                                                                                                                                , dtiConNm = _dataDictNm
                                                                                                                                                                                                                                                                                                                                                                                                                                                                , dtiConFldAnnL = replicate (length _clsAllFldL) 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 (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 (__tup34) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 { (_,_clsArgTyL) | _clsArgTyL `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 (case (appConApp _dataDictNm _clsArgTyL) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  { _dataDictTy | _dataDictTy `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (case (ValGamInfo (assocLElts _clsAllFldL `appArr` _dataDictTy)) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   { _vgi | _vgi `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   (case (gamAdd _dataDictNm _vgi _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 ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     _lhsIcSubst `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     (_lhsIchrEvidBindMp `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      (_lhsIchrScopeBindMp `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       (_lhsIfinTyVarMp `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (_lhsIfinValGam `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         (_lhsIisStrict `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          (_lhsIkiSigGam `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           (_lhsImoduleNm `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (_lhsIrangeMp `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             (_lhsIsysfEnv `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 (_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) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          { ( _declsIallErrSq,_declsIbangEvalL,_declsIcSubst,_declsIerrSq,_declsIffeCBindL,_declsIffiCBindL,_declsIgathHiddenExports,_declsIgathLamMp,_declsIgathMentrelFilterMp,_declsIgathTvKiVarMp,_declsIorphanS,_declsIpp,_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 (_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 _funcDepsOtyKiGlobFreeTvarS _funcDepsOtyTyGlobFreeTvarS _funcDepsOtyTyTySigFreeTvarS _funcDepsOvalTyGlobFreeTvarS) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           { ( _funcDepsIallErrSq,_funcDepsIerrSq,_funcDepsIfuncDeps,_funcDepsIgathMentrelFilterMp,_funcDepsIpp,_funcDepsIppL,_funcDepsIrange) | 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 (_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 _tyPrExprOtyKiGlobFreeTvarS _tyPrExprOtyTyGlobFreeTvarS _tyPrExprOtyTyTySigFreeTvarS _tyPrExprOvalTyGlobFreeTvarS) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 { ( _tyPrExprIallErrSq,_tyPrExprIappArgPPL,_tyPrExprIappFunNm,_tyPrExprIappFunPP,_tyPrExprIclMissNmS,_tyPrExprIclNmS,_tyPrExprIerrSq,_tyPrExprIgathMentrelFilterMp,_tyPrExprIpp,_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 (_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
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | (n,t) <- _clsFldL
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ]) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    { _lhsOvalCBindL | _lhsOvalCBindL `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ( _lhsOallErrSq,_lhsObangEvalL,_lhsOcSubst,_lhsOerrSq,_lhsOffeCBindL,_lhsOffiCBindL,_lhsOgathHiddenExports,_lhsOgathLamMp,_lhsOgathMentrelFilterMp,_lhsOgathTvKiVarMp,_lhsOorphanS,_lhsOpp,_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,_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
                                        { __tup52 | __tup52 `seq` (True) ->
                                        (case (__tup52) 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 =
                                                                                                                                                                                                                                     (\ _lhsIkiVarMp
                                                                                                                                                                                                                                        _lhsImbKnPolCtx
                                                                                                                                                                                                                                        _lhsIopts
                                                                                                                                                                                                                                        _lhsIpolGam
                                                                                                                                                                                                                                        _lhsIpolVarMp
                                                                                                                                                                                                                                        _lhsIpredScope
                                                                                                                                                                                                                                        _lhsItyKiGlobFreeTvarS ->
                                                                                                                                                                                                                                          _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 (__tup52) 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 (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 _declsOkiVarMp _declsOmbKnPolCtx _declsOopts _declsOpolGam _declsOpolVarMp _declsOpredScope _declsOtyKiGlobFreeTvarS) of
                                                                                                                                                                                                                                                                                             { ( _declsIgenerDataInfoL,_declsIkiVarMp,_declsIpolVarMp,decls_8) | True ->
                                                                                                                                                                                                                                                                                                 (case (_declsIgenerDataInfoL) of
                                                                                                                                                                                                                                                                                                  { _lhsOgenerDataInfoL | _lhsOgenerDataInfoL `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 (__tup52) of
                                                                                                                                                                                                                                                                                                                                                                                                                                          { (_,_,_,_,_,_,_,_,_,_,_,_lUniq_9_prTyFix,_,_,_) | _lUniq_9_prTyFix `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                          (case (__tup52) of
                                                                                                                                                                                                                                                                                                                                                                                                                                           { (_,_lUniq,_,_,_,_,_,_,_,_,_,_,_,_,_) | _lUniq `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                           (case (mkPrIdCHR _lUniq) of
                                                                                                                                                                                                                                                                                                                                                                                                                                            { _instId | _instId `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                            (case (maybe (poiHNm _instId,True) id mbNmElim_) of
                                                                                                                                                                                                                                                                                                                                                                                                                                             { __tup49 | __tup49 `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                             (case (__tup49) of
                                                                                                                                                                                                                                                                                                                                                                                                                                              { (_,_inclForElim) | _inclForElim `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                              (case (__tup49) of
                                                                                                                                                                                                                                                                                                                                                                                                                                               { (_dictNm,_) | _dictNm `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                               (case (tyFixTyVars _lUniq_9_prTyFix $ tyQuantifyRank [2..] $ tyCanonic (emptyTyBetaRedEnv' emptyFE)  _tyPrExprIty) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                { __tup46 | __tup46 `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                (case (__tup46) 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
                                                                                                                                                                                                                                                                                                                                                                                                                                                  { __tup47 | __tup47 `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                  (case (__tup47) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                   { (_,_hdPrTyFix,_,_,_,_,_,_,_,_,_) | _hdPrTyFix `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                   (case (__tup47) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                    { (_ctxtPrTyFixL,_,_,_,_,_,_,_,_,_,_) | _ctxtPrTyFixL `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                    (case (__tup46) 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
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    { __tup48 | __tup48 `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (case (__tup48) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     { (_instClsNm,_) | _instClsNm `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     (case (hsnClass2Dict _instClsNm) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      { _dataDictNm | _dataDictNm `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      (case (__tup48) 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 ((case instVariant_ of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               InstDefault -> [_dataDictTy]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               _           -> map pred2DataTy _ctxtPrFixL
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             ) `appArr` _dataDictTy)) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          { _vgi | _vgi `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          (case (gamAdd _dictNm _vgi _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 (__tup46) 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 ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          _lhsIcSubst `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          (_lhsIchrEvidBindMp `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           (_lhsIchrScopeBindMp `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (_lhsIfinTyVarMp `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             (_lhsIfinValGam `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              (_lhsIisStrict `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               (_lhsIkiSigGam `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (_lhsImoduleNm `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 (_lhsIrangeMp `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (_lhsIsysfEnv `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 (__tup52) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          { (_,_,_,_,_,_,_,_,_,_,_,_,_,_,_lUniq_generDeriv2) | _lUniq_generDeriv2 `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          (case (__tup52) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           { (_,_,_,_,_,_,_,_,_,_,_,_,_,_lUniq_generDeriv1,_) | _lUniq_generDeriv1 `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           (case (__tup52) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            { (_,_,_,_,_,_,_,_,_,_,_lUniq_95_fitsIn_dataTy,_,_,_,_) | _lUniq_95_fitsIn_dataTy `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (case (__tup52) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             { (_,_,_,_,_,_,_,_,_,_lUniq_95_extraPrOcc,_,_,_,_,_) | _lUniq_95_extraPrOcc `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             (case (__tup52) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              { (_,_,_,_,_,_,_,_,_lUniq_95_altsPrOcc,_,_,_,_,_,_) | _lUniq_95_altsPrOcc `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              (case (__tup52) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               { (_,_,_,_,_,_,_lUniq7,_,_,_,_,_,_,_,_) | _lUniq7 `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               (case (__tup52) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                { (_,_,_,_,_,_lUniq6,_,_,_,_,_,_,_,_,_) | _lUniq6 `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (case (__tup52) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 { (_,_,_,_,_lUniq5,_,_,_,_,_,_,_,_,_,_) | _lUniq5 `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 (case (__tup52) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  { (_,_,_,_lUniq4,_,_,_,_,_,_,_,_,_,_,_) | _lUniq4 `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (case (__tup52) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   { (_,_,_lUniq3,_,_,_,_,_,_,_,_,_,_,_,_) | _lUniq3 `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   (case (defaultFIEnv
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              { feEHCOpts = _lhsIopts
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              , fePredScope = _lhsIpredScope
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              , feTyGam = _lhsItyGam
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              , fePolGam = _lhsIpolGam
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              , feRange = _range
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              }) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    { _fe | _fe `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (case (maybe emptyCLGI id (gamLookup _instClsNm _lhsIclGam)) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     { _clgi | _clgi `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     (case (__tup47) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      { (_,_,_,_,_,_,_,_,_,_,_derivTruncTailArity) | _derivTruncTailArity `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      (case (__tup47) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       { (_,_,_,_,_,_,_,_,_,_derivArity,_) | _derivArity `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       (case (__tup47) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        { (_,_,_,_,_,_,_,_,_derivDataTyNm,_,_) | _derivDataTyNm `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (case (__tup47) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         { (_,_,_,_,_,_,_,_derivDataTyArgs,_,_,_) | _derivDataTyArgs `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         (case (__tup47) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          { (_,_,_,_,_,_derivDataDGI,_,_,_,_,_) | _derivDataDGI `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          (case (case instVariant_ of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   InstDeriving _ | 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
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            { __tup37 | __tup37 `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (case (__tup37) 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 (mkDerivClsMp _fe _lhsIvalGam _lhsIdataGam) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  { _derivMp | _derivMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (case (__tup47) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   { (_,_,_,_,_derivDataTGI,_,_,_,_,_,_) | _derivDataTGI `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   (case (__tup47) 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 (_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 _tyPrExprOtyKiGlobFreeTvarS _tyPrExprOtyTyGlobFreeTvarS _tyPrExprOtyTyTySigFreeTvarS _tyPrExprOvalTyGlobFreeTvarS) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               { ( _tyPrExprIallErrSq,_tyPrExprIappArgPPL,_tyPrExprIappFunNm,_tyPrExprIappFunPP,_tyPrExprIclMissNmS,_tyPrExprIclNmS,_tyPrExprIerrSq,_tyPrExprIgathMentrelFilterMp,_tyPrExprIpp,_tyPrExprItyWildL) | True ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   (case (let mke m = [rngLift _range Err_NoDerivForData _derivHdDataTy _instClsNm m]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              hasFlds = any (\t -> ctagArity t > 0)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              builtinNms = ehcOptBuiltinNames _lhsIopts
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          in  case ( Map.lookup _instClsNm _derivMp
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   , instVariant_
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   , panicJust "Decl.Instance.dataGamTagsOfTy" $ dataGamTagsOfTy (tgiTy _derivDataTGI) _lhsIdataGam
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   )
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (Nothing,InstDeriving _,_)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | null _generForFitsInL
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  -> [rngLift _range Err_NoDerivFor _tyPrExprIpp]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (Just _,InstDeriving _,[])
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  -> mke "has no constructors"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (Just _,InstDeriving _,ctags)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | _instClsNm `elem`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       [ ehbnClassEnum builtinNms
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       , ehbnClassIx   builtinNms
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       ]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    && hasFlds ctags
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -> mke "has a constructor with >0 fields"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (Just _,InstDeriving _,ctags@(_:_:_))
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | _instClsNm == ehbnClassBounded builtinNms
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    && hasFlds ctags
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    -> 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
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      { __tup50 | __tup50 `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      (case (__tup50) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       { (_,_dictSelfNm) | _dictSelfNm `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       (case (__tup50) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        { (_dictBuildNm,_) | _dictBuildNm `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (case (__tup47) 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
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           { __tup38 | __tup38 `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           (case (__tup38) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            { (_,_chrSuperProveCnstrMp,_,_,_,_,_,_,_) | _chrSuperProveCnstrMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (case (__tup38) 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
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                { __tup42 | __tup42 `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (case (__tup42) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 { (_,_chrSolveSuperRemCnstrMp,_,_,_,_,_,_,_,_) | _chrSolveSuperRemCnstrMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 (case (__tup37) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  { (_foGenerDerivL,_) | _foGenerDerivL `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (case (cnstrMpUnions $ map foGathCnstrMp _foGenerDerivL) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   { _generCnstrMp | _generCnstrMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   (case (case instVariant_ of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            InstDeriving _
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | isJust derivDCL
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                && not (dgiIsRec _derivDataDGI)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                -> ( gathPredLToProveCnstrMp $ foVarMp foDt `varUpd` concat (extraPrOcc : altsPrOcc)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   , altsPrOcc, extraPrOcc
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   , fromJust derivDCL
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   )
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | not $ null _generForFitsInL
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                -> ( 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 derivDCL
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    foDt = fitsIn unifyFIOpts _fe _lUniq_95_fitsIn_dataTy (emptyVarMp :: VarMp) dataTy _derivHdDataTy
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    derivDCL = Map.lookup _instClsNm _derivMp
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _ -> (_tyVarMpDeclsL0         `varUpd` _declsIgathCnstrMp,[],[],emptyDerivCls)) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    { __tup39 | __tup39 `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (case (__tup39) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     { (_toProveGathCnstrMp,_,_,_) | _toProveGathCnstrMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     (case (__tup38) 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
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        { __tup40 | __tup40 `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (case (__tup40) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         { (_,_chrSolveDeclsRemCnstrMp,_,_,_,_,_,_,_,_) | _chrSolveDeclsRemCnstrMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         (case (cnstrMpUnions [_chrSolveDeclsRemCnstrMp,_chrSolveSuperRemCnstrMp]) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          { _toAssumeNeverCnstrMp | _toAssumeNeverCnstrMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          (case (__tup42) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           { (_,_,_cannotResSuperCnstrMp,_,_,_,_,_,_,_) | _cannotResSuperCnstrMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           (case (__tup40) 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 (__tup47) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                { (_,_,_,_,_,_,_cxSplitErrs,_,_,_,_) | _cxSplitErrs `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (case (__tup42) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 { (_,_,_,_,_chrSolveSuperErrs,_,_,_,_,_) | _chrSolveSuperErrs `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 (case (__tup40) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  { (_,_,_,_,_chrSolveDeclsErrs,_,_,_,_,_) | _chrSolveDeclsErrs `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (case (Seq.firstNotEmpty
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           [ 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 (_lhsImoduleNm) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    { _declsOmoduleNm | _declsOmoduleNm `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (case (_lhsIkiSigGam) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     { _declsOkiSigGam | _declsOkiSigGam `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     (case (_lhsIisStrict) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      { _declsOisStrict | _declsOisStrict `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      (case (__tup40) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       { (_,_,_,_,_,_,_,_,_chrSolveDeclsScopeBindMp,_) | _chrSolveDeclsScopeBindMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       (case (_chrSolveDeclsScopeBindMp `predScopeToBindMapUnion` _lhsIchrScopeBindMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        { _chrScopeBindMp | _chrScopeBindMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (case (_chrScopeBindMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         { _declsOchrScopeBindMp | _declsOchrScopeBindMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         (case (__tup40) 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) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               { ( _declsIallErrSq,_declsIbangEvalL,_declsIcSubst,_declsIerrSq,_declsIffeCBindL,_declsIffiCBindL,_declsIgathHiddenExports,_declsIgathLamMp,_declsIgathMentrelFilterMp,_declsIgathTvKiVarMp,_declsIorphanS,_declsIpp,_declsItyCBindL,_declsIvalCBindL) | True ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   (case (Seq.unions [_lErrSq, _declsIallErrSq]) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    { _lhsOallErrSq | _lhsOallErrSq `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (case (_declsIbangEvalL) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     { _lhsObangEvalL | _lhsObangEvalL `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     (case (__tup52) 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 (__tup39) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           { (_,_,_derivExtraPrOcc,_) | _derivExtraPrOcc `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           (case (__tup39) 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 (__tup38) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               { (_,_,_,_chrCtxtArgUIDL,_,_,_,_,_) | _chrCtxtArgUIDL `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               (case (mkAssumeBindings _chrCtxtArgUIDL _chrEvidBindMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                { _chrAssumeDeclsCtxtBindL | _chrAssumeDeclsCtxtBindL `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (case (__tup38) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 { (_,_,_,_,_,_,_,_chrInstArgUID,_) | _chrInstArgUID `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 (case (mkAssumeBindings [_chrInstArgUID] _chrEvidBindMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  { _chrAssumeDeclsInstBindL | _chrAssumeDeclsInstBindL `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (case (__tup42) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   { (_,_,_,_,_,_,_,_chrSolveSuperEvidBindMp,_,_) | _chrSolveSuperEvidBindMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   (case (mkAssumeBindings _chrCtxtArgUIDL _chrSolveSuperEvidBindMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    { _chrAssumeSuperBindL | _chrAssumeSuperBindL `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (case (mkScopeBindings True _predScope _chrSolveDeclsScopeBindMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     { __tup45 | __tup45 `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     (case (__tup45) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      { (_chrScopeDeclsBindL,_) | _chrScopeDeclsBindL `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      (case (__tup42) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       { (_,_,_,_,_,_,_,_,_chrSolveSuperScopeBindMp,_) | _chrSolveSuperScopeBindMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       (case (mkScopeBindings True _predScope _chrSolveSuperScopeBindMp) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        { __tup44 | __tup44 `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (case (__tup44) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         { (_chrScopeSuperBindL,_) | _chrScopeSuperBindL `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         (case (__tup39) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          { (_,_,_,_derivDCL) | _derivDCL `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          (case (__tup38) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           { (_,_,_,_,_,_,_chrSuperProveNmL,_,_) | _chrSuperProveNmL `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           (case (__tup38) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            { (_,_,_,_,_chrCtxtArgNmL,_,_,_,_) | _chrCtxtArgNmL `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (case (let (bindL,cSubstInstL) =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            case instVariant_ of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              InstNormal   -> (_declsIvalCBindL,[])
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              InstDefault  -> (_declsIvalCBindL,[])
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              InstDeriving _
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | not $ null _generForFitsInL
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           -> 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 ++ _chrScopeDeclsBindL
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         , _chrScopeSuperBindL
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         , _chrAssumeSuperBindL ++ _chrAssumeDeclsCtxtBindL
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         )
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       , foldr cSubstApp emptyCSubst cSubstInstL
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       )) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             { __tup51 | __tup51 `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             (case (__tup51) 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 (__tup42) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     { (_,_,_,_,_,_chrSuperSimplifyResult,_,_,_,_) | _chrSuperSimplifyResult `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     (case (__tup40) 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 (_declsItyCBindL) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   { _lhsOtyCBindL | _lhsOtyCBindL `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   (case (__tup51) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    { (_lhsOvalCBindL,_) | _lhsOvalCBindL `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ( _lhsOallErrSq,_lhsObangEvalL,_lhsOcSubst,_lhsOerrSq,_lhsOffeCBindL,_lhsOffiCBindL,_lhsOgathHiddenExports,_lhsOgathLamMp,_lhsOgathMentrelFilterMp,_lhsOgathTvKiVarMp,_lhsOorphanS,_lhsOpp,_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,_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
                                        { __tup54 | __tup54 `seq` (True) ->
                                        (case (__tup54) 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 =
                                                                                                                                                                                                           (\ _lhsIkiVarMp
                                                                                                                                                                                                              _lhsImbKnPolCtx
                                                                                                                                                                                                              _lhsIopts
                                                                                                                                                                                                              _lhsIpolGam
                                                                                                                                                                                                              _lhsIpolVarMp
                                                                                                                                                                                                              _lhsIpredScope
                                                                                                                                                                                                              _lhsItyKiGlobFreeTvarS ->
                                                                                                                                                                                                                _lhsIkiVarMp `seq`
                                                                                                                                                                                                                (_lhsImbKnPolCtx `seq`
                                                                                                                                                                                                                 (_lhsIopts `seq`
                                                                                                                                                                                                                  (_lhsIpolGam `seq`
                                                                                                                                                                                                                   (_lhsIpolVarMp `seq`
                                                                                                                                                                                                                    (_lhsIpredScope `seq`
                                                                                                                                                                                                                     (_lhsItyKiGlobFreeTvarS `seq`
                                                                                                                                                                                                                      ((case ([]) of
                                                                                                                                                                                                                        { _lhsOgenerDataInfoL | _lhsOgenerDataInfoL `seq` (True) ->
                                                                                                                                                                                                                        (case (_lhsItyKiGam) of
                                                                                                                                                                                                                         { _prExprOtyKiGam | _prExprOtyKiGam `seq` (True) ->
                                                                                                                                                                                                                         (case (_lhsItyGam) of
                                                                                                                                                                                                                          { _prExprOtyGam | _prExprOtyGam `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 (expr_3 _exprOkiVarMp _exprOopts _exprOpolGam _exprOpolVarMp _exprOpredScope _exprOtyGam _exprOtyKiGam _exprOtyKiGlobFreeTvarS) of
                                                                                                                                                                                                                                   { ( _exprIkiVarMp,_exprIpolVarMp,expr_4) | True ->
                                                                                                                                                                                                                                       (case (_exprIpolVarMp) of
                                                                                                                                                                                                                                        { _prExprOpolVarMp | _prExprOpolVarMp `seq` (True) ->
                                                                                                                                                                                                                                        (case (_lhsIpolGam) of
                                                                                                                                                                                                                                         { _prExprOpolGam | _prExprOpolGam `seq` (True) ->
                                                                                                                                                                                                                                         (case (_exprIkiVarMp) of
                                                                                                                                                                                                                                          { _prExprOkiVarMp | _prExprOkiVarMp `seq` (True) ->
                                                                                                                                                                                                                                          (case (__tup54) 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 (__tup54) of
                                                                                                                                                                                                                                                                                                                                                                                           { (_,_,_,_lUniq_9_prTyMeta) | _lUniq_9_prTyMeta `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                           (case (__tup54) 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 _lUniq emptyVarMp _prExprIty _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 ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  _lhsIcSubst `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (_lhsIchrEvidBindMp `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   (_lhsIchrScopeBindMp `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (_lhsIfinTyVarMp `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     (_lhsIfinValGam `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      (_lhsIisStrict `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       (_lhsIkiSigGam `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (_lhsImoduleNm `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         (_lhsIrangeMp `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          (_lhsIsysfEnv `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 (_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 _prExprOtyKiGlobFreeTvarS _prExprOtyTyGlobFreeTvarS _prExprOtyTyTySigFreeTvarS _prExprOvalTyGlobFreeTvarS) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    { ( _prExprIallErrSq,_prExprIclMissNmS,_prExprIclNmS,_prExprIerrSq,_prExprIgathMentrelFilterMp,_prExprIpp,_prExprIpr) | 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) 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,_exprIorphanS,_exprIpp) | 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 ([]) 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,_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,_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
                                   { __tup55 | __tup55 `seq` (True) ->
                                   (case (__tup55) 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 =
                                                                                                                                                                                       (\ _lhsIkiVarMp
                                                                                                                                                                                          _lhsImbKnPolCtx
                                                                                                                                                                                          _lhsIopts
                                                                                                                                                                                          _lhsIpolGam
                                                                                                                                                                                          _lhsIpolVarMp
                                                                                                                                                                                          _lhsIpredScope
                                                                                                                                                                                          _lhsItyKiGlobFreeTvarS ->
                                                                                                                                                                                            _lhsIkiVarMp `seq`
                                                                                                                                                                                            (_lhsImbKnPolCtx `seq`
                                                                                                                                                                                             (_lhsIopts `seq`
                                                                                                                                                                                              (_lhsIpolGam `seq`
                                                                                                                                                                                               (_lhsIpolVarMp `seq`
                                                                                                                                                                                                (_lhsIpredScope `seq`
                                                                                                                                                                                                 (_lhsItyKiGlobFreeTvarS `seq`
                                                                                                                                                                                                  ((case ([]) of
                                                                                                                                                                                                    { _lhsOgenerDataInfoL | _lhsOgenerDataInfoL `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 ->
                                                                                                                                                                                                                                                                                                                                                                                                                      _lhsIcSubst `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                      (_lhsIchrEvidBindMp `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                       (_lhsIchrScopeBindMp `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                        (_lhsIfinTyVarMp `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                         (_lhsIfinValGam `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                          (_lhsIisStrict `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                           (_lhsIkiSigGam `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                            (_lhsImoduleNm `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                             (_lhsIrangeMp `seq`
                                                                                                                                                                                                                                                                                                                                                                                                                              (_lhsIsysfEnv `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 (_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 (__tup55) 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 _tyExprsOtyKiGlobFreeTvarS _tyExprsOtyTyGlobFreeTvarS _tyExprsOtyTyTySigFreeTvarS _tyExprsOvalTyGlobFreeTvarS) of
                                                                                                                                                                                                                                                                                                                                                                                                                                               { ( _tyExprsIallErrSq,_tyExprsIclMissNmS,_tyExprsIclNmS,_tyExprsIerrSq,_tyExprsIgathMentrelFilterMp,_tyExprsIpp,_tyExprsIppL) | 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 ([]) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  { _lhsOtyCBindL | _lhsOtyCBindL `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (case ([]) of
                                                                                                                                                                                                                                                                                                                                                                                                                                                                   { _lhsOvalCBindL | _lhsOvalCBindL `seq` (True) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                   ( _lhsOallErrSq,_lhsObangEvalL,_lhsOcSubst,_lhsOerrSq,_lhsOffeCBindL,_lhsOffiCBindL,_lhsOgathHiddenExports,_lhsOgathLamMp,_lhsOgathMentrelFilterMp,_lhsOgathTvKiVarMp,_lhsOorphanS,_lhsOpp,_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,_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) }) }) }) })