packages feed

uhc-light-1.1.7.0: src/UHC/Light/Compiler/EH/MainAG_DataConstrs.hs



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

-- DataConstrs -------------------------------------------------
{-
   visit 0:
      synthesized attribute:
         range                : Range
   visit 1:
      chained attribute:
         gUniq                : UID
   visit 2:
      inherited attributes:
         dataTy               : Ty
         knPolCtx             : Polarity
         polGam               : PolGam
         tyGam                : TyGam
      chained attribute:
         polVarMp             : VarMp
      synthesized attributes:
         dataAltTyL           : AssocL HsName Ty
         gathMaxArity         : Int
   visit 3:
      inherited attributes:
         dataAltTy            : Ty
         maxArity             : Int
         tyKiGam              : TyKiGam
         tyNm                 : HsName
      chained attribute:
         kiVarMp              : VarMp
      synthesized attributes:
         dataAltForNewType    : Ty
         dataConstrNmL        : [HsName]
         dataConstrTagMp      : DataConstrTagMp
         intlTyKiGam          : TyKiGam
   visit 4:
      inherited attributes:
         finTyKiGam           : TyKiGam
         tvKiVarMp            : VarMp
      chained attributes:
         patTyVarMp           : VarMp
         patValGam            : ValGam
      synthesized attributes:
         fldSelGam            : ValGam
         fldUpdGam            : ValGam
         gathCnstrMp          : CHRPredOccCnstrMp
         gathRangeMp          : RangeMp
   visit 5:
      inherited attributes:
         chrEvidBindMp        : EvidKeyToCBindMap
         chrScopeBindMp       : PredScopeToCBindMap
         chrStore             : ScopedPredStore
         clDfGam              : ClassDefaultGam
         clGam                : ClGam
         finKiVarMp           : VarMp
         finTyVarMp           : VarMp
         isNewtype            : Bool
         kiGam                : KiGam
         lexLev               : Int
         moduleNm             : HsName
         opts                 : EHCOpts
         predScope            : PredScope
         rangeMp              : RangeMp
         sysfEnv              : ToSysfEnv
         tyKiGlobFreeTvarS    : TyVarIdS
         tyTyGlobFreeTvarS    : TyVarIdS
         tyTyTySigFreeTvarS   : TyVarIdS
         valGam               : ValGam
         valTyGlobFreeTvarS   : TyVarIdS
      synthesized attributes:
         allErrSq             : ErrSq
         errSq                : ErrSq
         ffeCBindL            : CBindL
         ffiCBindL            : CBindL
         gathMentrelFilterMp  : ModEntRelFilterMp
         gathTvKiVarMp        : VarMp
         pp                   : PP_Doc
         ppL                  : [PP_Doc]
         tyCBindL             : CBindL
         valCBindL            : CBindL
   alternatives:
      alternative Cons:
         child hd             : DataConstr 
         child tl             : DataConstrs 
      alternative Nil:
-}
sem_DataConstrs_Cons :: T_DataConstr ->
                        T_DataConstrs ->
                        T_DataConstrs

sem_DataConstrs_Cons hd_ tl_ | hd_ `seq` (tl_ `seq` (True)) =
    (case (tl_) of
     { ( _tlIrange,tl_1) | True ->
         (case (hd_) of
          { ( _hdIrange,hd_1) | True ->
              (case (_hdIrange `rangeUnion` _tlIrange) of
               { _lhsOrange | _lhsOrange `seq` (True) ->
               (case ((let sem_DataConstrs_Cons_1 :: T_DataConstrs_1
                           sem_DataConstrs_Cons_1 =
                               (\ _lhsIgUniq ->
                                    _lhsIgUniq `seq`
                                    ((case (_lhsIgUniq) of
                                      { _hdOgUniq | _hdOgUniq `seq` (True) ->
                                      (case (hd_1 _hdOgUniq) of
                                       { ( _hdIgUniq,hd_2) | True ->
                                           (case (_hdIgUniq) of
                                            { _tlOgUniq | _tlOgUniq `seq` (True) ->
                                            (case (tl_1 _tlOgUniq) of
                                             { ( _tlIgUniq,tl_2) | True ->
                                                 (case (_tlIgUniq) of
                                                  { _lhsOgUniq | _lhsOgUniq `seq` (True) ->
                                                  (case ((let sem_DataConstrs_Cons_2 :: T_DataConstrs_2
                                                              sem_DataConstrs_Cons_2 =
                                                                  (\ _lhsIdataTy
                                                                     _lhsIknPolCtx
                                                                     _lhsIpolGam
                                                                     _lhsIpolVarMp
                                                                     _lhsItyGam ->
                                                                       _lhsIdataTy `seq`
                                                                       (_lhsIknPolCtx `seq`
                                                                        (_lhsIpolGam `seq`
                                                                         (_lhsIpolVarMp `seq`
                                                                          (_lhsItyGam `seq`
                                                                           ((case (_lhsItyGam) of
                                                                             { _tlOtyGam | _tlOtyGam `seq` (True) ->
                                                                             (case (_lhsIdataTy) of
                                                                              { _tlOdataTy | _tlOdataTy `seq` (True) ->
                                                                              (case (_lhsItyGam) of
                                                                               { _hdOtyGam | _hdOtyGam `seq` (True) ->
                                                                               (case (_lhsIdataTy) of
                                                                                { _hdOdataTy | _hdOdataTy `seq` (True) ->
                                                                                (case (_lhsIpolVarMp) of
                                                                                 { _hdOpolVarMp | _hdOpolVarMp `seq` (True) ->
                                                                                 (case (_lhsIpolGam) of
                                                                                  { _hdOpolGam | _hdOpolGam `seq` (True) ->
                                                                                  (case (_lhsIknPolCtx) of
                                                                                   { _hdOknPolCtx | _hdOknPolCtx `seq` (True) ->
                                                                                   (case (hd_2 _hdOdataTy _hdOknPolCtx _hdOpolGam _hdOpolVarMp _hdOtyGam) of
                                                                                    { ( _hdIdataAltTyL,_hdIgathMaxArity,_hdIpolVarMp,hd_3) | True ->
                                                                                        (case (_hdIpolVarMp) of
                                                                                         { _tlOpolVarMp | _tlOpolVarMp `seq` (True) ->
                                                                                         (case (_lhsIpolGam) of
                                                                                          { _tlOpolGam | _tlOpolGam `seq` (True) ->
                                                                                          (case (_lhsIknPolCtx) of
                                                                                           { _tlOknPolCtx | _tlOknPolCtx `seq` (True) ->
                                                                                           (case (tl_2 _tlOdataTy _tlOknPolCtx _tlOpolGam _tlOpolVarMp _tlOtyGam) of
                                                                                            { ( _tlIdataAltTyL,_tlIgathMaxArity,_tlIpolVarMp,tl_3) | True ->
                                                                                                (case (_hdIdataAltTyL ++ _tlIdataAltTyL) of
                                                                                                 { _lhsOdataAltTyL | _lhsOdataAltTyL `seq` (True) ->
                                                                                                 (case (_hdIgathMaxArity `max` _tlIgathMaxArity) of
                                                                                                  { _lhsOgathMaxArity | _lhsOgathMaxArity `seq` (True) ->
                                                                                                  (case (_tlIpolVarMp) of
                                                                                                   { _lhsOpolVarMp | _lhsOpolVarMp `seq` (True) ->
                                                                                                   (case ((let sem_DataConstrs_Cons_3 :: T_DataConstrs_3
                                                                                                               sem_DataConstrs_Cons_3 =
                                                                                                                   (\ _lhsIdataAltTy
                                                                                                                      _lhsIkiVarMp
                                                                                                                      _lhsImaxArity
                                                                                                                      _lhsItyKiGam
                                                                                                                      _lhsItyNm ->
                                                                                                                        _lhsIdataAltTy `seq`
                                                                                                                        (_lhsIkiVarMp `seq`
                                                                                                                         (_lhsImaxArity `seq`
                                                                                                                          (_lhsItyKiGam `seq`
                                                                                                                           (_lhsItyNm `seq`
                                                                                                                            ((case (_lhsItyNm) of
                                                                                                                              { _tlOtyNm | _tlOtyNm `seq` (True) ->
                                                                                                                              (case (_lhsItyKiGam) of
                                                                                                                               { _tlOtyKiGam | _tlOtyKiGam `seq` (True) ->
                                                                                                                               (case (_lhsImaxArity) of
                                                                                                                                { _tlOmaxArity | _tlOmaxArity `seq` (True) ->
                                                                                                                                (case (_lhsItyKiGam) of
                                                                                                                                 { _hdOtyKiGam | _hdOtyKiGam `seq` (True) ->
                                                                                                                                 (case (_lhsIkiVarMp) of
                                                                                                                                  { _hdOkiVarMp | _hdOkiVarMp `seq` (True) ->
                                                                                                                                  (case (_lhsItyNm) of
                                                                                                                                   { _hdOtyNm | _hdOtyNm `seq` (True) ->
                                                                                                                                   (case (_lhsImaxArity) of
                                                                                                                                    { _hdOmaxArity | _hdOmaxArity `seq` (True) ->
                                                                                                                                    (case (_lhsIdataAltTy) of
                                                                                                                                     { _hdOdataAltTy | _hdOdataAltTy `seq` (True) ->
                                                                                                                                     (case (hd_3 _hdOdataAltTy _hdOkiVarMp _hdOmaxArity _hdOtyKiGam _hdOtyNm) of
                                                                                                                                      { ( _hdIdataAltForNewType,_hdIdataConstrNmL,_hdIdataConstrTagMp,_hdIintlTyKiGam,_hdIkiVarMp,hd_4) | True ->
                                                                                                                                          (case (_hdIkiVarMp) of
                                                                                                                                           { _tlOkiVarMp | _tlOkiVarMp `seq` (True) ->
                                                                                                                                           (case (_lhsIdataAltTy) of
                                                                                                                                            { _tlOdataAltTy | _tlOdataAltTy `seq` (True) ->
                                                                                                                                            (case (tl_3 _tlOdataAltTy _tlOkiVarMp _tlOmaxArity _tlOtyKiGam _tlOtyNm) of
                                                                                                                                             { ( _tlIdataAltForNewType,_tlIdataConstrNmL,_tlIdataConstrTagMp,_tlIintlTyKiGam,_tlIkiVarMp,tl_4) | True ->
                                                                                                                                                 (case (_hdIdataAltForNewType `const` _tlIdataAltForNewType) of
                                                                                                                                                  { _lhsOdataAltForNewType | _lhsOdataAltForNewType `seq` (True) ->
                                                                                                                                                  (case (_hdIdataConstrNmL ++ _tlIdataConstrNmL) of
                                                                                                                                                   { _lhsOdataConstrNmL | _lhsOdataConstrNmL `seq` (True) ->
                                                                                                                                                   (case (_hdIdataConstrTagMp `Map.union` _tlIdataConstrTagMp) of
                                                                                                                                                    { _lhsOdataConstrTagMp | _lhsOdataConstrTagMp `seq` (True) ->
                                                                                                                                                    (case (_hdIintlTyKiGam `gamUnion` _tlIintlTyKiGam) of
                                                                                                                                                     { _lhsOintlTyKiGam | _lhsOintlTyKiGam `seq` (True) ->
                                                                                                                                                     (case (_tlIkiVarMp) of
                                                                                                                                                      { _lhsOkiVarMp | _lhsOkiVarMp `seq` (True) ->
                                                                                                                                                      (case ((let sem_DataConstrs_Cons_4 :: T_DataConstrs_4
                                                                                                                                                                  sem_DataConstrs_Cons_4 =
                                                                                                                                                                      (\ _lhsIfinTyKiGam
                                                                                                                                                                         _lhsIpatTyVarMp
                                                                                                                                                                         _lhsIpatValGam
                                                                                                                                                                         _lhsItvKiVarMp ->
                                                                                                                                                                           _lhsIfinTyKiGam `seq`
                                                                                                                                                                           (_lhsIpatTyVarMp `seq`
                                                                                                                                                                            (_lhsIpatValGam `seq`
                                                                                                                                                                             (_lhsItvKiVarMp `seq`
                                                                                                                                                                              ((case (_lhsItvKiVarMp) of
                                                                                                                                                                                { _tlOtvKiVarMp | _tlOtvKiVarMp `seq` (True) ->
                                                                                                                                                                                (case (_lhsIpatValGam) of
                                                                                                                                                                                 { _hdOpatValGam | _hdOpatValGam `seq` (True) ->
                                                                                                                                                                                 (case (_lhsItvKiVarMp) of
                                                                                                                                                                                  { _hdOtvKiVarMp | _hdOtvKiVarMp `seq` (True) ->
                                                                                                                                                                                  (case (_lhsIpatTyVarMp) of
                                                                                                                                                                                   { _hdOpatTyVarMp | _hdOpatTyVarMp `seq` (True) ->
                                                                                                                                                                                   (case (_lhsIfinTyKiGam) of
                                                                                                                                                                                    { _hdOfinTyKiGam | _hdOfinTyKiGam `seq` (True) ->
                                                                                                                                                                                    (case (hd_4 _hdOfinTyKiGam _hdOpatTyVarMp _hdOpatValGam _hdOtvKiVarMp) of
                                                                                                                                                                                     { ( _hdIfldSelGam,_hdIfldUpdGam,_hdIgathCnstrMp,_hdIgathRangeMp,_hdIpatTyVarMp,_hdIpatValGam,hd_5) | True ->
                                                                                                                                                                                         (case (_hdIpatValGam) of
                                                                                                                                                                                          { _tlOpatValGam | _tlOpatValGam `seq` (True) ->
                                                                                                                                                                                          (case (_hdIpatTyVarMp) of
                                                                                                                                                                                           { _tlOpatTyVarMp | _tlOpatTyVarMp `seq` (True) ->
                                                                                                                                                                                           (case (_lhsIfinTyKiGam) of
                                                                                                                                                                                            { _tlOfinTyKiGam | _tlOfinTyKiGam `seq` (True) ->
                                                                                                                                                                                            (case (tl_4 _tlOfinTyKiGam _tlOpatTyVarMp _tlOpatValGam _tlOtvKiVarMp) of
                                                                                                                                                                                             { ( _tlIfldSelGam,_tlIfldUpdGam,_tlIgathCnstrMp,_tlIgathRangeMp,_tlIpatTyVarMp,_tlIpatValGam,tl_5) | True ->
                                                                                                                                                                                                 (case (_hdIfldSelGam `gamUnion` _tlIfldSelGam) of
                                                                                                                                                                                                  { _lhsOfldSelGam | _lhsOfldSelGam `seq` (True) ->
                                                                                                                                                                                                  (case (_hdIfldUpdGam `gamUnion` _tlIfldUpdGam) of
                                                                                                                                                                                                   { _lhsOfldUpdGam | _lhsOfldUpdGam `seq` (True) ->
                                                                                                                                                                                                   (case (_hdIgathCnstrMp `cnstrMpUnion` _tlIgathCnstrMp) of
                                                                                                                                                                                                    { _lhsOgathCnstrMp | _lhsOgathCnstrMp `seq` (True) ->
                                                                                                                                                                                                    (case (_hdIgathRangeMp `Map.union` _tlIgathRangeMp) of
                                                                                                                                                                                                     { _lhsOgathRangeMp | _lhsOgathRangeMp `seq` (True) ->
                                                                                                                                                                                                     (case (_tlIpatTyVarMp) of
                                                                                                                                                                                                      { _lhsOpatTyVarMp | _lhsOpatTyVarMp `seq` (True) ->
                                                                                                                                                                                                      (case (_tlIpatValGam) of
                                                                                                                                                                                                       { _lhsOpatValGam | _lhsOpatValGam `seq` (True) ->
                                                                                                                                                                                                       (case ((let sem_DataConstrs_Cons_5 :: T_DataConstrs_5
                                                                                                                                                                                                                   sem_DataConstrs_Cons_5 =
                                                                                                                                                                                                                       (\ _lhsIchrEvidBindMp
                                                                                                                                                                                                                          _lhsIchrScopeBindMp
                                                                                                                                                                                                                          _lhsIchrStore
                                                                                                                                                                                                                          _lhsIclDfGam
                                                                                                                                                                                                                          _lhsIclGam
                                                                                                                                                                                                                          _lhsIfinKiVarMp
                                                                                                                                                                                                                          _lhsIfinTyVarMp
                                                                                                                                                                                                                          _lhsIisNewtype
                                                                                                                                                                                                                          _lhsIkiGam
                                                                                                                                                                                                                          _lhsIlexLev
                                                                                                                                                                                                                          _lhsImoduleNm
                                                                                                                                                                                                                          _lhsIopts
                                                                                                                                                                                                                          _lhsIpredScope
                                                                                                                                                                                                                          _lhsIrangeMp
                                                                                                                                                                                                                          _lhsIsysfEnv
                                                                                                                                                                                                                          _lhsItyKiGlobFreeTvarS
                                                                                                                                                                                                                          _lhsItyTyGlobFreeTvarS
                                                                                                                                                                                                                          _lhsItyTyTySigFreeTvarS
                                                                                                                                                                                                                          _lhsIvalGam
                                                                                                                                                                                                                          _lhsIvalTyGlobFreeTvarS ->
                                                                                                                                                                                                                            _lhsIchrEvidBindMp `seq`
                                                                                                                                                                                                                            (_lhsIchrScopeBindMp `seq`
                                                                                                                                                                                                                             (_lhsIchrStore `seq`
                                                                                                                                                                                                                              (_lhsIclDfGam `seq`
                                                                                                                                                                                                                               (_lhsIclGam `seq`
                                                                                                                                                                                                                                (_lhsIfinKiVarMp `seq`
                                                                                                                                                                                                                                 (_lhsIfinTyVarMp `seq`
                                                                                                                                                                                                                                  (_lhsIisNewtype `seq`
                                                                                                                                                                                                                                   (_lhsIkiGam `seq`
                                                                                                                                                                                                                                    (_lhsIlexLev `seq`
                                                                                                                                                                                                                                     (_lhsImoduleNm `seq`
                                                                                                                                                                                                                                      (_lhsIopts `seq`
                                                                                                                                                                                                                                       (_lhsIpredScope `seq`
                                                                                                                                                                                                                                        (_lhsIrangeMp `seq`
                                                                                                                                                                                                                                         (_lhsIsysfEnv `seq`
                                                                                                                                                                                                                                          (_lhsItyKiGlobFreeTvarS `seq`
                                                                                                                                                                                                                                           (_lhsItyTyGlobFreeTvarS `seq`
                                                                                                                                                                                                                                            (_lhsItyTyTySigFreeTvarS `seq`
                                                                                                                                                                                                                                             (_lhsIvalGam `seq`
                                                                                                                                                                                                                                              (_lhsIvalTyGlobFreeTvarS `seq`
                                                                                                                                                                                                                                               ((case (_lhsIvalTyGlobFreeTvarS) of
                                                                                                                                                                                                                                                 { _tlOvalTyGlobFreeTvarS | _tlOvalTyGlobFreeTvarS `seq` (True) ->
                                                                                                                                                                                                                                                 (case (_lhsIvalGam) of
                                                                                                                                                                                                                                                  { _tlOvalGam | _tlOvalGam `seq` (True) ->
                                                                                                                                                                                                                                                  (case (_lhsItyTyTySigFreeTvarS) of
                                                                                                                                                                                                                                                   { _tlOtyTyTySigFreeTvarS | _tlOtyTyTySigFreeTvarS `seq` (True) ->
                                                                                                                                                                                                                                                   (case (_lhsItyTyGlobFreeTvarS) of
                                                                                                                                                                                                                                                    { _tlOtyTyGlobFreeTvarS | _tlOtyTyGlobFreeTvarS `seq` (True) ->
                                                                                                                                                                                                                                                    (case (_lhsItyKiGlobFreeTvarS) of
                                                                                                                                                                                                                                                     { _tlOtyKiGlobFreeTvarS | _tlOtyKiGlobFreeTvarS `seq` (True) ->
                                                                                                                                                                                                                                                     (case (_lhsIsysfEnv) of
                                                                                                                                                                                                                                                      { _tlOsysfEnv | _tlOsysfEnv `seq` (True) ->
                                                                                                                                                                                                                                                      (case (_lhsIrangeMp) of
                                                                                                                                                                                                                                                       { _tlOrangeMp | _tlOrangeMp `seq` (True) ->
                                                                                                                                                                                                                                                       (case (_lhsIpredScope) of
                                                                                                                                                                                                                                                        { _tlOpredScope | _tlOpredScope `seq` (True) ->
                                                                                                                                                                                                                                                        (case (_lhsIopts) of
                                                                                                                                                                                                                                                         { _tlOopts | _tlOopts `seq` (True) ->
                                                                                                                                                                                                                                                         (case (_lhsImoduleNm) of
                                                                                                                                                                                                                                                          { _tlOmoduleNm | _tlOmoduleNm `seq` (True) ->
                                                                                                                                                                                                                                                          (case (_lhsIlexLev) of
                                                                                                                                                                                                                                                           { _tlOlexLev | _tlOlexLev `seq` (True) ->
                                                                                                                                                                                                                                                           (case (_lhsIkiGam) of
                                                                                                                                                                                                                                                            { _tlOkiGam | _tlOkiGam `seq` (True) ->
                                                                                                                                                                                                                                                            (case (_lhsIisNewtype) of
                                                                                                                                                                                                                                                             { _tlOisNewtype | _tlOisNewtype `seq` (True) ->
                                                                                                                                                                                                                                                             (case (_lhsIfinTyVarMp) of
                                                                                                                                                                                                                                                              { _tlOfinTyVarMp | _tlOfinTyVarMp `seq` (True) ->
                                                                                                                                                                                                                                                              (case (_lhsIfinKiVarMp) of
                                                                                                                                                                                                                                                               { _tlOfinKiVarMp | _tlOfinKiVarMp `seq` (True) ->
                                                                                                                                                                                                                                                               (case (_lhsIclGam) of
                                                                                                                                                                                                                                                                { _tlOclGam | _tlOclGam `seq` (True) ->
                                                                                                                                                                                                                                                                (case (_lhsIclDfGam) of
                                                                                                                                                                                                                                                                 { _tlOclDfGam | _tlOclDfGam `seq` (True) ->
                                                                                                                                                                                                                                                                 (case (_lhsIchrStore) of
                                                                                                                                                                                                                                                                  { _tlOchrStore | _tlOchrStore `seq` (True) ->
                                                                                                                                                                                                                                                                  (case (_lhsIchrScopeBindMp) of
                                                                                                                                                                                                                                                                   { _tlOchrScopeBindMp | _tlOchrScopeBindMp `seq` (True) ->
                                                                                                                                                                                                                                                                   (case (_lhsIchrEvidBindMp) of
                                                                                                                                                                                                                                                                    { _tlOchrEvidBindMp | _tlOchrEvidBindMp `seq` (True) ->
                                                                                                                                                                                                                                                                    (case (tl_5 _tlOchrEvidBindMp _tlOchrScopeBindMp _tlOchrStore _tlOclDfGam _tlOclGam _tlOfinKiVarMp _tlOfinTyVarMp _tlOisNewtype _tlOkiGam _tlOlexLev _tlOmoduleNm _tlOopts _tlOpredScope _tlOrangeMp _tlOsysfEnv _tlOtyKiGlobFreeTvarS _tlOtyTyGlobFreeTvarS _tlOtyTyTySigFreeTvarS _tlOvalGam _tlOvalTyGlobFreeTvarS) of
                                                                                                                                                                                                                                                                     { ( _tlIallErrSq,_tlIerrSq,_tlIffeCBindL,_tlIffiCBindL,_tlIgathMentrelFilterMp,_tlIgathTvKiVarMp,_tlIpp,_tlIppL,_tlItyCBindL,_tlIvalCBindL) | True ->
                                                                                                                                                                                                                                                                         (case (_lhsIvalTyGlobFreeTvarS) of
                                                                                                                                                                                                                                                                          { _hdOvalTyGlobFreeTvarS | _hdOvalTyGlobFreeTvarS `seq` (True) ->
                                                                                                                                                                                                                                                                          (case (_lhsIvalGam) of
                                                                                                                                                                                                                                                                           { _hdOvalGam | _hdOvalGam `seq` (True) ->
                                                                                                                                                                                                                                                                           (case (_lhsItyTyTySigFreeTvarS) of
                                                                                                                                                                                                                                                                            { _hdOtyTyTySigFreeTvarS | _hdOtyTyTySigFreeTvarS `seq` (True) ->
                                                                                                                                                                                                                                                                            (case (_lhsItyTyGlobFreeTvarS) of
                                                                                                                                                                                                                                                                             { _hdOtyTyGlobFreeTvarS | _hdOtyTyGlobFreeTvarS `seq` (True) ->
                                                                                                                                                                                                                                                                             (case (_lhsItyKiGlobFreeTvarS) of
                                                                                                                                                                                                                                                                              { _hdOtyKiGlobFreeTvarS | _hdOtyKiGlobFreeTvarS `seq` (True) ->
                                                                                                                                                                                                                                                                              (case (_lhsIsysfEnv) of
                                                                                                                                                                                                                                                                               { _hdOsysfEnv | _hdOsysfEnv `seq` (True) ->
                                                                                                                                                                                                                                                                               (case (_lhsIrangeMp) of
                                                                                                                                                                                                                                                                                { _hdOrangeMp | _hdOrangeMp `seq` (True) ->
                                                                                                                                                                                                                                                                                (case (_lhsIpredScope) of
                                                                                                                                                                                                                                                                                 { _hdOpredScope | _hdOpredScope `seq` (True) ->
                                                                                                                                                                                                                                                                                 (case (_lhsIopts) of
                                                                                                                                                                                                                                                                                  { _hdOopts | _hdOopts `seq` (True) ->
                                                                                                                                                                                                                                                                                  (case (_lhsImoduleNm) of
                                                                                                                                                                                                                                                                                   { _hdOmoduleNm | _hdOmoduleNm `seq` (True) ->
                                                                                                                                                                                                                                                                                   (case (_lhsIlexLev) of
                                                                                                                                                                                                                                                                                    { _hdOlexLev | _hdOlexLev `seq` (True) ->
                                                                                                                                                                                                                                                                                    (case (_lhsIkiGam) of
                                                                                                                                                                                                                                                                                     { _hdOkiGam | _hdOkiGam `seq` (True) ->
                                                                                                                                                                                                                                                                                     (case (_lhsIisNewtype) of
                                                                                                                                                                                                                                                                                      { _hdOisNewtype | _hdOisNewtype `seq` (True) ->
                                                                                                                                                                                                                                                                                      (case (_lhsIfinTyVarMp) of
                                                                                                                                                                                                                                                                                       { _hdOfinTyVarMp | _hdOfinTyVarMp `seq` (True) ->
                                                                                                                                                                                                                                                                                       (case (_lhsIfinKiVarMp) of
                                                                                                                                                                                                                                                                                        { _hdOfinKiVarMp | _hdOfinKiVarMp `seq` (True) ->
                                                                                                                                                                                                                                                                                        (case (_lhsIclGam) of
                                                                                                                                                                                                                                                                                         { _hdOclGam | _hdOclGam `seq` (True) ->
                                                                                                                                                                                                                                                                                         (case (_lhsIclDfGam) of
                                                                                                                                                                                                                                                                                          { _hdOclDfGam | _hdOclDfGam `seq` (True) ->
                                                                                                                                                                                                                                                                                          (case (_lhsIchrStore) of
                                                                                                                                                                                                                                                                                           { _hdOchrStore | _hdOchrStore `seq` (True) ->
                                                                                                                                                                                                                                                                                           (case (_lhsIchrScopeBindMp) of
                                                                                                                                                                                                                                                                                            { _hdOchrScopeBindMp | _hdOchrScopeBindMp `seq` (True) ->
                                                                                                                                                                                                                                                                                            (case (_lhsIchrEvidBindMp) of
                                                                                                                                                                                                                                                                                             { _hdOchrEvidBindMp | _hdOchrEvidBindMp `seq` (True) ->
                                                                                                                                                                                                                                                                                             (case (hd_5 _hdOchrEvidBindMp _hdOchrScopeBindMp _hdOchrStore _hdOclDfGam _hdOclGam _hdOfinKiVarMp _hdOfinTyVarMp _hdOisNewtype _hdOkiGam _hdOlexLev _hdOmoduleNm _hdOopts _hdOpredScope _hdOrangeMp _hdOsysfEnv _hdOtyKiGlobFreeTvarS _hdOtyTyGlobFreeTvarS _hdOtyTyTySigFreeTvarS _hdOvalGam _hdOvalTyGlobFreeTvarS) of
                                                                                                                                                                                                                                                                                              { ( _hdIallErrSq,_hdIerrSq,_hdIffeCBindL,_hdIffiCBindL,_hdIgathMentrelFilterMp,_hdIgathTvKiVarMp,_hdIpp,_hdItyCBindL,_hdIvalCBindL) | True ->
                                                                                                                                                                                                                                                                                                  (case (_hdIallErrSq `Seq.union` _tlIallErrSq) of
                                                                                                                                                                                                                                                                                                   { _lhsOallErrSq | _lhsOallErrSq `seq` (True) ->
                                                                                                                                                                                                                                                                                                   (case (_hdIerrSq `Seq.union` _tlIerrSq) of
                                                                                                                                                                                                                                                                                                    { _lhsOerrSq | _lhsOerrSq `seq` (True) ->
                                                                                                                                                                                                                                                                                                    (case (_hdIffeCBindL ++ _tlIffeCBindL) of
                                                                                                                                                                                                                                                                                                     { _lhsOffeCBindL | _lhsOffeCBindL `seq` (True) ->
                                                                                                                                                                                                                                                                                                     (case (_hdIffiCBindL ++ _tlIffiCBindL) of
                                                                                                                                                                                                                                                                                                      { _lhsOffiCBindL | _lhsOffiCBindL `seq` (True) ->
                                                                                                                                                                                                                                                                                                      (case (_hdIgathMentrelFilterMp `mentrelFilterMpUnion` _tlIgathMentrelFilterMp) of
                                                                                                                                                                                                                                                                                                       { _lhsOgathMentrelFilterMp | _lhsOgathMentrelFilterMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                       (case (_hdIgathTvKiVarMp `varmpUnion` _tlIgathTvKiVarMp) of
                                                                                                                                                                                                                                                                                                        { _lhsOgathTvKiVarMp | _lhsOgathTvKiVarMp `seq` (True) ->
                                                                                                                                                                                                                                                                                                        (case (_hdIpp >-< _tlIpp) of
                                                                                                                                                                                                                                                                                                         { _lhsOpp | _lhsOpp `seq` (True) ->
                                                                                                                                                                                                                                                                                                         (case (_hdIpp : _tlIppL) of
                                                                                                                                                                                                                                                                                                          { _lhsOppL | _lhsOppL `seq` (True) ->
                                                                                                                                                                                                                                                                                                          (case (_hdItyCBindL ++ _tlItyCBindL) of
                                                                                                                                                                                                                                                                                                           { _lhsOtyCBindL | _lhsOtyCBindL `seq` (True) ->
                                                                                                                                                                                                                                                                                                           (case (_hdIvalCBindL ++ _tlIvalCBindL) of
                                                                                                                                                                                                                                                                                                            { _lhsOvalCBindL | _lhsOvalCBindL `seq` (True) ->
                                                                                                                                                                                                                                                                                                            ( _lhsOallErrSq,_lhsOerrSq,_lhsOffeCBindL,_lhsOffiCBindL,_lhsOgathMentrelFilterMp,_lhsOgathTvKiVarMp,_lhsOpp,_lhsOppL,_lhsOtyCBindL,_lhsOvalCBindL) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }))))))))))))))))))))))
                                                                                                                                                                                                               in  sem_DataConstrs_Cons_5)) of
                                                                                                                                                                                                        { ( sem_DataConstrs_5) | True ->
                                                                                                                                                                                                        ( _lhsOfldSelGam,_lhsOfldUpdGam,_lhsOgathCnstrMp,_lhsOgathRangeMp,_lhsOpatTyVarMp,_lhsOpatValGam,sem_DataConstrs_5) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }))))))
                                                                                                                                                              in  sem_DataConstrs_Cons_4)) of
                                                                                                                                                       { ( sem_DataConstrs_4) | True ->
                                                                                                                                                       ( _lhsOdataAltForNewType,_lhsOdataConstrNmL,_lhsOdataConstrTagMp,_lhsOintlTyKiGam,_lhsOkiVarMp,sem_DataConstrs_4) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) })))))))
                                                                                                           in  sem_DataConstrs_Cons_3)) of
                                                                                                    { ( sem_DataConstrs_3) | True ->
                                                                                                    ( _lhsOdataAltTyL,_lhsOgathMaxArity,_lhsOpolVarMp,sem_DataConstrs_3) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) })))))))
                                                          in  sem_DataConstrs_Cons_2)) of
                                                   { ( sem_DataConstrs_2) | True ->
                                                   ( _lhsOgUniq,sem_DataConstrs_2) }) }) }) }) }) })))
                       in  sem_DataConstrs_Cons_1)) of
                { ( sem_DataConstrs_1) | True ->
                ( _lhsOrange,sem_DataConstrs_1) }) }) }) })

sem_DataConstrs_Nil :: T_DataConstrs

sem_DataConstrs_Nil =
    (case (emptyRange) of
     { _lhsOrange | _lhsOrange `seq` (True) ->
     (case ((let sem_DataConstrs_Nil_1 :: T_DataConstrs_1
                 sem_DataConstrs_Nil_1 =
                     (\ _lhsIgUniq ->
                          _lhsIgUniq `seq`
                          ((case (_lhsIgUniq) of
                            { _lhsOgUniq | _lhsOgUniq `seq` (True) ->
                            (case ((let sem_DataConstrs_Nil_2 :: T_DataConstrs_2
                                        sem_DataConstrs_Nil_2 =
                                            (\ _lhsIdataTy
                                               _lhsIknPolCtx
                                               _lhsIpolGam
                                               _lhsIpolVarMp
                                               _lhsItyGam ->
                                                 _lhsIdataTy `seq`
                                                 (_lhsIknPolCtx `seq`
                                                  (_lhsIpolGam `seq`
                                                   (_lhsIpolVarMp `seq`
                                                    (_lhsItyGam `seq`
                                                     ((case ([]) of
                                                       { _lhsOdataAltTyL | _lhsOdataAltTyL `seq` (True) ->
                                                       (case (0) of
                                                        { _lhsOgathMaxArity | _lhsOgathMaxArity `seq` (True) ->
                                                        (case (_lhsIpolVarMp) of
                                                         { _lhsOpolVarMp | _lhsOpolVarMp `seq` (True) ->
                                                         (case ((let sem_DataConstrs_Nil_3 :: T_DataConstrs_3
                                                                     sem_DataConstrs_Nil_3 =
                                                                         (\ _lhsIdataAltTy
                                                                            _lhsIkiVarMp
                                                                            _lhsImaxArity
                                                                            _lhsItyKiGam
                                                                            _lhsItyNm ->
                                                                              _lhsIdataAltTy `seq`
                                                                              (_lhsIkiVarMp `seq`
                                                                               (_lhsImaxArity `seq`
                                                                                (_lhsItyKiGam `seq`
                                                                                 (_lhsItyNm `seq`
                                                                                  ((case (Ty_Any) of
                                                                                    { _lhsOdataAltForNewType | _lhsOdataAltForNewType `seq` (True) ->
                                                                                    (case ([]) of
                                                                                     { _lhsOdataConstrNmL | _lhsOdataConstrNmL `seq` (True) ->
                                                                                     (case (Map.empty) of
                                                                                      { _lhsOdataConstrTagMp | _lhsOdataConstrTagMp `seq` (True) ->
                                                                                      (case (emptyGam) of
                                                                                       { _lhsOintlTyKiGam | _lhsOintlTyKiGam `seq` (True) ->
                                                                                       (case (_lhsIkiVarMp) of
                                                                                        { _lhsOkiVarMp | _lhsOkiVarMp `seq` (True) ->
                                                                                        (case ((let sem_DataConstrs_Nil_4 :: T_DataConstrs_4
                                                                                                    sem_DataConstrs_Nil_4 =
                                                                                                        (\ _lhsIfinTyKiGam
                                                                                                           _lhsIpatTyVarMp
                                                                                                           _lhsIpatValGam
                                                                                                           _lhsItvKiVarMp ->
                                                                                                             _lhsIfinTyKiGam `seq`
                                                                                                             (_lhsIpatTyVarMp `seq`
                                                                                                              (_lhsIpatValGam `seq`
                                                                                                               (_lhsItvKiVarMp `seq`
                                                                                                                ((case (emptyGam) of
                                                                                                                  { _lhsOfldSelGam | _lhsOfldSelGam `seq` (True) ->
                                                                                                                  (case (emptyGam) of
                                                                                                                   { _lhsOfldUpdGam | _lhsOfldUpdGam `seq` (True) ->
                                                                                                                   (case (Map.empty) of
                                                                                                                    { _lhsOgathCnstrMp | _lhsOgathCnstrMp `seq` (True) ->
                                                                                                                    (case (Map.empty) of
                                                                                                                     { _lhsOgathRangeMp | _lhsOgathRangeMp `seq` (True) ->
                                                                                                                     (case (_lhsIpatTyVarMp) of
                                                                                                                      { _lhsOpatTyVarMp | _lhsOpatTyVarMp `seq` (True) ->
                                                                                                                      (case (_lhsIpatValGam) of
                                                                                                                       { _lhsOpatValGam | _lhsOpatValGam `seq` (True) ->
                                                                                                                       (case ((let sem_DataConstrs_Nil_5 :: T_DataConstrs_5
                                                                                                                                   sem_DataConstrs_Nil_5 =
                                                                                                                                       (\ _lhsIchrEvidBindMp
                                                                                                                                          _lhsIchrScopeBindMp
                                                                                                                                          _lhsIchrStore
                                                                                                                                          _lhsIclDfGam
                                                                                                                                          _lhsIclGam
                                                                                                                                          _lhsIfinKiVarMp
                                                                                                                                          _lhsIfinTyVarMp
                                                                                                                                          _lhsIisNewtype
                                                                                                                                          _lhsIkiGam
                                                                                                                                          _lhsIlexLev
                                                                                                                                          _lhsImoduleNm
                                                                                                                                          _lhsIopts
                                                                                                                                          _lhsIpredScope
                                                                                                                                          _lhsIrangeMp
                                                                                                                                          _lhsIsysfEnv
                                                                                                                                          _lhsItyKiGlobFreeTvarS
                                                                                                                                          _lhsItyTyGlobFreeTvarS
                                                                                                                                          _lhsItyTyTySigFreeTvarS
                                                                                                                                          _lhsIvalGam
                                                                                                                                          _lhsIvalTyGlobFreeTvarS ->
                                                                                                                                            _lhsIchrEvidBindMp `seq`
                                                                                                                                            (_lhsIchrScopeBindMp `seq`
                                                                                                                                             (_lhsIchrStore `seq`
                                                                                                                                              (_lhsIclDfGam `seq`
                                                                                                                                               (_lhsIclGam `seq`
                                                                                                                                                (_lhsIfinKiVarMp `seq`
                                                                                                                                                 (_lhsIfinTyVarMp `seq`
                                                                                                                                                  (_lhsIisNewtype `seq`
                                                                                                                                                   (_lhsIkiGam `seq`
                                                                                                                                                    (_lhsIlexLev `seq`
                                                                                                                                                     (_lhsImoduleNm `seq`
                                                                                                                                                      (_lhsIopts `seq`
                                                                                                                                                       (_lhsIpredScope `seq`
                                                                                                                                                        (_lhsIrangeMp `seq`
                                                                                                                                                         (_lhsIsysfEnv `seq`
                                                                                                                                                          (_lhsItyKiGlobFreeTvarS `seq`
                                                                                                                                                           (_lhsItyTyGlobFreeTvarS `seq`
                                                                                                                                                            (_lhsItyTyTySigFreeTvarS `seq`
                                                                                                                                                             (_lhsIvalGam `seq`
                                                                                                                                                              (_lhsIvalTyGlobFreeTvarS `seq`
                                                                                                                                                               ((case (Seq.empty) of
                                                                                                                                                                 { _lhsOallErrSq | _lhsOallErrSq `seq` (True) ->
                                                                                                                                                                 (case (Seq.empty) of
                                                                                                                                                                  { _lhsOerrSq | _lhsOerrSq `seq` (True) ->
                                                                                                                                                                  (case ([]) of
                                                                                                                                                                   { _lhsOffeCBindL | _lhsOffeCBindL `seq` (True) ->
                                                                                                                                                                   (case ([]) of
                                                                                                                                                                    { _lhsOffiCBindL | _lhsOffiCBindL `seq` (True) ->
                                                                                                                                                                    (case (Map.empty) of
                                                                                                                                                                     { _lhsOgathMentrelFilterMp | _lhsOgathMentrelFilterMp `seq` (True) ->
                                                                                                                                                                     (case (emptyVarMp) of
                                                                                                                                                                      { _lhsOgathTvKiVarMp | _lhsOgathTvKiVarMp `seq` (True) ->
                                                                                                                                                                      (case (empty) of
                                                                                                                                                                       { _lhsOpp | _lhsOpp `seq` (True) ->
                                                                                                                                                                       (case ([]) of
                                                                                                                                                                        { _lhsOppL | _lhsOppL `seq` (True) ->
                                                                                                                                                                        (case ([]) of
                                                                                                                                                                         { _lhsOtyCBindL | _lhsOtyCBindL `seq` (True) ->
                                                                                                                                                                         (case ([]) of
                                                                                                                                                                          { _lhsOvalCBindL | _lhsOvalCBindL `seq` (True) ->
                                                                                                                                                                          ( _lhsOallErrSq,_lhsOerrSq,_lhsOffeCBindL,_lhsOffiCBindL,_lhsOgathMentrelFilterMp,_lhsOgathTvKiVarMp,_lhsOpp,_lhsOppL,_lhsOtyCBindL,_lhsOvalCBindL) }) }) }) }) }) }) }) }) }) }))))))))))))))))))))))
                                                                                                                               in  sem_DataConstrs_Nil_5)) of
                                                                                                                        { ( sem_DataConstrs_5) | True ->
                                                                                                                        ( _lhsOfldSelGam,_lhsOfldUpdGam,_lhsOgathCnstrMp,_lhsOgathRangeMp,_lhsOpatTyVarMp,_lhsOpatValGam,sem_DataConstrs_5) }) }) }) }) }) }) }))))))
                                                                                                in  sem_DataConstrs_Nil_4)) of
                                                                                         { ( sem_DataConstrs_4) | True ->
                                                                                         ( _lhsOdataAltForNewType,_lhsOdataConstrNmL,_lhsOdataConstrTagMp,_lhsOintlTyKiGam,_lhsOkiVarMp,sem_DataConstrs_4) }) }) }) }) }) })))))))
                                                                 in  sem_DataConstrs_Nil_3)) of
                                                          { ( sem_DataConstrs_3) | True ->
                                                          ( _lhsOdataAltTyL,_lhsOgathMaxArity,_lhsOpolVarMp,sem_DataConstrs_3) }) }) }) })))))))
                                    in  sem_DataConstrs_Nil_2)) of
                             { ( sem_DataConstrs_2) | True ->
                             ( _lhsOgUniq,sem_DataConstrs_2) }) })))
             in  sem_DataConstrs_Nil_1)) of
      { ( sem_DataConstrs_1) | True ->
      ( _lhsOrange,sem_DataConstrs_1) }) })