one  = CmmLit (CmmInt 1 (wordWidth platform))

 -- Now look for multiplication/division by powers of 2 (integers).

   = case mop of

         MO_Mul rep

                  Just $! (cmmMachOpFold platform (MO_Shl rep) [x, CmmLit (CmmInt p $ wordWidth platform)])

         MO_U_Quot rep

                  Just $! (cmmMachOpFold platform (MO_U_Shr rep) [x, CmmLit (CmmInt p $ wordWidth platform)])

         MO_U_Rem rep

                  Just $! (cmmMachOpFold platform (MO_And rep) [x, CmmLit (CmmInt (n - 1) rep)])

         MO_S_Quot rep

              CmmReg _ <- x ->   -- We duplicate x in signedQuotRemHelper, hence require

                                 -- it is a reg.  FIXME: remove this restriction.

                 Just $! (cmmMachOpFold platform (MO_S_Shr rep)

                   [signedQuotRemHelper rep p, CmmLit (CmmInt p $ wordWidth platform)])

         MO_S_Rem rep

              CmmReg _ <- x ->   -- We duplicate x in signedQuotRemHelper, hence require

                                 -- it is a reg.  FIXME: remove this restriction.

                 -- We replace (x `rem` 2^p) by (x - (x `quot` 2^p) * 2^p).

                                                     -- See Note [Free vars and synonyms]

 tyCoFVsOfType (LitTy {})         f bound_vars acc = emptyFV f bound_vars acc

 tyCoFVsOfType (AppTy fun arg)    f bound_vars acc = (tyCoFVsOfType fun `unionFV` tyCoFVsOfType arg) f bound_vars acc

 tyCoFVsOfType (ForAllTy bndr ty) f bound_vars acc = tyCoFVsBndr bndr (tyCoFVsOfType ty)  f bound_vars acc

 tyCoFVsOfType (CastTy ty co)     f bound_vars acc = (tyCoFVsOfType ty `unionFV` tyCoFVsOfCo co) f bound_vars acc

 tyCoFVsOfType (CoercionTy co)    f bound_vars acc = tyCoFVsOfCo co f bound_vars acc

                           = go ty'

     go (TyVarTy v)        = go (tyVarKind v)

     go (AppTy f a)        = go f `unionFV` go a

     go (TyConApp tc tys)  = tyCoFVsOfTypes invisibles `unionFV`

                             invisibleVarsOfTypes visibles

       where (invisibles, visibles) = partitionInvisibleTypes tc tys

     go_ty _   (LitTy {})        = mempty

     go_ty env (CastTy ty co)    = go_ty env ty `mappend` go_co env co

     go_ty env (CoercionTy co)   = go_co env co

     go_ty env (TyConApp _ tys)  = go_tys env tys

     go_ty env (ForAllTy (Bndr tv vis) inner)

       = let !env' = tycobinder env tv vis  -- Avoid building a thunk here

 hsLTyVarNames :: [LHsTyVarBndr flag (GhcPass p)] -> [IdP (GhcPass p)]

 hsLTyVarNames = mapMaybe hsLTyVarName

 hsForAllTelescopeBndrs :: HsForAllTelescope (GhcPass p) -> [LHsTyVarBndr ForAllTyFlag (GhcPass p)]

 hsForAllTelescopeBndrs (HsForAllVis   _ bndrs) = map (fmap (setHsTyVarBndrFlag Required)) bndrs

 hsForAllTelescopeBndrs (HsForAllInvis _ bndrs) = map (fmap (updateHsTyVarBndrFlag Invisible)) bndrs

     -- Uses accumulating-parameter style

     go dv (AppTy t1 t2)       = foldlM go dv [t1, t2]

     go dv (TyConApp tc tys)   = go_tc_args dv (tyConBinders tc) tys

     go dv (LitTy {})          = return dv

     go dv (CastTy ty co)      = do { dv1 <- go dv ty

                                    ; collect_cand_qtvs_co orig_ty cur_lvl bound dv1 co }

     go _            (LitTy {})         = []

     go is_invis_arg (ForAllTy bndr ty) = go is_invis_arg (binderType bndr)

                                          ++ go is_invis_arg ty

                                          ++ go is_invis_arg ty2

     go is_invis_arg ty@(AppTy _ _)     =

       let (ty_head, ty_args) = splitAppTys ty

         FieldOcc(..), LFieldOcc,

         mapHsOuterImplicit,

         isHsKindedTyVar

     ) where

 import GHC.Hs.Doc (LHsDoc)

 import GHC.Data.FastString (FastString)

 import Data.Data hiding ( Fixity, Prefix, Infix )

 import Data.Maybe

     }

   | XLHsQTyVars !(XXLHsQTyVars pass)

 ------------------------------------------------

 --            HsOuterTyVarBndrs

 -- Used to quantify the outermost type variable binders of a type that obeys

 {-# OPTIONS_HADDOCK not-home #-}

 -- |

    ( Num(..)

    , subtract

    , quotRemInteger

    )

 where

 import GHC.Internal.Num

                 grep_errmsg(r'(12\.345|0\.6640625)',[1]),

                 ],

      compile, ['-ddump-cmm'])

   xorNatural :: Natural -> Natural -> Natural

 module GHC.Num where

   type Integer :: *

   data Integer = IS GHC.Internal.Prim.Int# | IP GHC.Internal.Prim.ByteArray# | IN GHC.Internal.Prim.ByteArray#

   type Natural :: *

   xorNatural :: Natural -> Natural -> Natural

 module GHC.Num where

   type Integer :: *

   data Integer = IS GHC.Internal.Prim.Int# | IP GHC.Internal.Prim.ByteArray# | IN GHC.Internal.Prim.ByteArray#

   type Natural :: *

   xorNatural :: Natural -> Natural -> Natural

 module GHC.Num where

   type Integer :: *

   data Integer = IS GHC.Internal.Prim.Int# | IP GHC.Internal.Prim.ByteArray# | IN GHC.Internal.Prim.ByteArray#

   type Natural :: *

   xorNatural :: Natural -> Natural -> Natural

 module GHC.Num where

   type Integer :: *

   data Integer = IS GHC.Internal.Prim.Int# | IP GHC.Internal.Prim.ByteArray# | IN GHC.Internal.Prim.ByteArray#

   type Natural :: *

         | associated = id

         | otherwise = (<+> keyword "family")

       famSig = case result of

         NoSig _ -> empty

 ppTyVars unicode tvs = map (ppHsTyVarBndr unicode . unLoc) tvs

 tyvarNames :: LHsQTyVars DocNameI -> [Maybe Name]

 declWithDoc :: LaTeX -> Maybe LaTeX -> LaTeX

 declWithDoc decl doc =

       hdr =

         hsep

           ( [keyword "type", ppBinder summary occ]

           )

       full = hdr <+> def

       def = case unLoc ltype of

   qual =

     hsep

       [ ppFamilyLeader associated info

       , ppResultSig result unicode qual

       , injAnn

       , whereBit

 ppClassHdr summ lctxt n tvs fds unicode qual =

   keyword "class"

     <+> (if not (null $ fromMaybeContext lctxt) then ppLContext lctxt unicode qual HideEmptyContexts else noHtml)

     <+> ppFds fds unicode qual

 ppFds :: [LHsFunDep DocNameI] -> Unicode -> Qualification -> Html

       ppLContext ctxt unicode qual HideEmptyContexts

       <+>

       -- T a b c ..., or a :+: b

       <+> case ks of

         Nothing -> mempty

         Just (L _ x) -> dcolon unicode <+> ppKind unicode qual x

 import Control.DeepSeq (force)

 import Data.Either (lefts, partitionEithers, rights)

 import GHC.Builtin.Names

   ( boxedRepDataConKey

   , eqTyConKey

                         hsq_explicit $

                           fdTyVars fd

                   , feqn_fixity = fdFixity fd

                   }

             extractAtItem

                     noLocA (MinimalSig (noAnn, NoSourceText) . noLocA $ classMinimalDef cl)

                       : [ noLocA tcdSig

                         | clsOp <- classOpItems cl

                         ]

                 , tcdMeths = [] -- ignore default method definitions, they don't affect signature

                 -- class associated-types are a subset of TyCon:

 synifyAxBranch tc (CoAxBranch{cab_tvs = tkvs, cab_lhs = args, cab_rhs = rhs}) =

   let name = synifyNameN tc

       args_types_only = filterOutInvisibleTypes tc args

       annot_typats = zipWith3 annotHsType args_poly args_types_only typats

       outer_bndrs = HsOuterImplicit{hso_ximplicit = map tyVarName tkvs}

    in -- TODO: this must change eventually

       FamEqn

           , tcdLName = synifyNameN tc

           , tcdTyVars = synifyTyVars (tyConVisibleTyVars tc)

           , tcdFixity = synifyFixity tc

           }

   -- (closed) newtype and data

   | otherwise = do

     linear_tys =

       zipWith

         ( \(Scaled mult ty) (HsSrcBang st unp str) ->

             in CDF (noAnn, st) unp str multSyn tySyn Nothing

         )

         arg_tys

               , con_inner_bndrs = inner_bndrs

               , con_mb_cxt = ctx

               , con_g_args = hat

               , con_doc = Nothing

               }

       else do

   -> SynifyTypeState

   -- ^ what to do with a 'forall'

   -> [TyVar]

   -> Id

   -- ^ the 'Id' from which to get the type signature

   -> Sig GhcRn

   where

     !n = force $ synifyNameN i

     t = defaultType prr (varType i)

 -- | Turn a 'ClassOpItem' into a list of signatures. The list returned is going

 -- to contain the synified 'ClassOpSig' as well (when appropriate) a default

 -- 'ClassOpSig'.

   [ClassOpSig noAnn False [synifyNameN i] (mainSig (varType i))]

     ++ [ ClassOpSig noAnn True [noLocA dn] (defSig dt)

        | Just (dn, GenericDM dt) <- [dm]

        ]

   where

 synifyCtx :: [PredType] -> LHsContext GhcRn

 synifyTyVars :: [TyVar] -> LHsQTyVars GhcRn

 synifyTyVars ktvs =

 synifyTyVarBndr' no_kinds (Bndr tv spec) = synify_ty_var no_kinds spec tv

 -- | Like 'synifyTyVarBndr', but accepts a set of variables for which to omit kind

 synify_ty_var :: VarSet -> flag -> TyVar -> LHsTyVarBndr flag GhcRn

 synify_ty_var no_kinds flag tv =

   noLocA (HsTvb noAnn flag bndr_var bndr_kind)

 annotHsType True ty hs_ty

   | not $ isEmptyVarSet $ filterVarSet isTyVar $ tyCoVarsOfType ty =

       let ki = typeKind ty

        in noLocA (HsKindSig noAnn hs_ty hs_ki)

 annotHsType _ _ hs_ty = hs_ty

     --   the defining class gets to quantify all its functions for free!

     DeleteTopLevelQuantification

 -- The use of mkEmptySigType (which uses empty binders in OuterImplicit)

 -- is a bit suspicious; what if the type has free variables?

 synifySigWcType :: SynifyTypeState -> [TyVar] -> Type -> LHsSigWcType GhcRn

 -- Ditto (see synifySigType)

 synifyPatSynSigType :: PatSyn -> LHsSigType GhcRn

 -- Ditto (see synifySigType)

 synifyType

   :: SynifyTypeState

   -- ^ what to do with a 'forall'

   -> Type

   -- ^ the type to convert

   -> LHsType GhcRn

 synifyType _ _ (TyVarTy tv) = noLocA $ HsTyVar noAnn NotPromoted $ noLocA (noUserRdr $ getName tv)

   maybe_sig res_ty

   where

     res_ty :: LHsType GhcRn

                   ConstraintTuple -> HsBoxedOrConstraintTuple

                   UnboxedTuple -> HsUnboxedTuple

               )

       | isUnboxedSumTyCon tc =

       | Just dc <- isPromotedDataCon_maybe tc

       , isTupleDataCon dc

       , dataConSourceArity dc == length vis_tys =

       -- ditto for lists

       | getName tc == listTyConName

       , [ty] <- vis_tys =

       | tc == promotedNilDataCon

       , [] <- vis_tys =

           noLocA $ HsExplicitListTy noExtField IsPromoted []

       | tc == promotedConsDataCon

       , [ty1, ty2] <- vis_tys =

                 tTy

                   | L _ (HsExplicitListTy _ IsPromoted tTy') <- stripKindSig tTy ->

                       noLocA $ HsExplicitListTy noExtField IsPromoted (hTy : tTy')

       | tc `hasKey` ipClassKey

       , [name, ty] <- tys

       , Just x <- isStrLitTy name =

       -- and equalities

       | tc `hasKey` eqTyConKey

       , [ty1, ty2] <- tys =

             HsOpTy

               noExtField

               NotPromoted

               (noLocA $ noUserRdr eqTyConName)

       -- and infix type operators

       | isSymOcc (nameOccName (getName tc))

       , ty1 : ty2 : tys_rest <- vis_tys =

             ( HsOpTy

                 noExtField

                 prom

                 (noLocA $ noUserRdr $ getName tc)

             )

             tys_rest

       -- Most TyCons:

           foldl

             (\t1 t2 -> noLocA $ HsAppTy noExtField t1 t2)

             (noLocA ty_app)

                 filterOut isCoercionTy ty_args

             )

     maybe_sig ty'

       | tyConAppNeedsKindSig False tc tys_len =

           let full_kind = typeKind (mkTyConApp tc tys)

            in noLocA $ HsKindSig noAnn ty' full_kind'

       | otherwise = ty'

   let

     (ty_head, ty_args) = splitAppTys ty

     ty_args' =

         filterOut isCoercionTy $

           filterByList

             (map isVisibleForAllTyFlag $ appTyForAllTyFlags ty_head ty_args)

             ty_args

    in

     foldl (\t1 t2 -> noLocA $ HsAppTy noExtField t1 t2) ty_head' ty_args'

   | otherwise = noLocA $ HsFunTy noExtField w' s1 s2

   where

   case argf of

 synifyType _ _ (LitTy t) = noLocA $ HsTyLit noExtField $ synifyTyLit t