#if MIN_VERSION_rts(1,0,3)

 import qualified Data.ByteString.Char8 as BS

 #endif

 import Data.IntMap (IntMap)

 import qualified Data.Map as Map

 import qualified Data.IntMap as IntMap

 import Data.Ord

 import Data.Either ( partitionEithers )

 -- | Maps Ids to their stack depth. This allows us to avoid having to mess with

 -- it after each push/pop.

 {-

 ppBCEnv :: BCEnv -> SDoc

          sum_szsb_args  = sum szsb_args

          -- Make a stack offset for each argument or free var -- they should

          -- appear contiguous in the stack, in order.

          -- make the arg bitmap

          bits = argBits platform (reverse (map (idArgRep platform) all_args))

 -- it, have to agree about this layout

 fvsToEnv p rhs =  [v | v <- dVarSetElems $ freeVarsOfRhs rhs,

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

 -- schemeE

         alloc_code <- mkConAppCode d s p data_con args

         platform <- targetPlatform <$> getDynFlags

         let !d2 = d + wordSize platform

         return (alloc_code `appOL` body_code)

 -- General case for let.  Generates correct, if inefficient, code in

 -- all situations.

          -- after the closures have been allocated in the heap (but not

          -- filled in), and pointers to them parked on the stack.

          offsets = mkStackOffsets d (genericReplicate n_binds (wordSize platform))

          d' = d + wordsToBytes platform n_binds

          -- ToDo: don't build thunks for things with no free variables

         -- Env in which to compile the alts, not including

         -- any vars bound by the alts themselves

         bndr_ty = idType bndr

         isAlgCase = isAlgType bndr_ty

                  stack_bot = d_alts

                         [ (arg, tuple_start -

                                 wordsToBytes platform (nativeCallSize call_info) +

                                 offset)

                         | (NonVoid arg, offset) <- args_offsets]

              in do

                rhs_code <- schemeE stack_bot s p' rhs

                return (NoDiscr, rhs_code)

                  stack_bot = d_alts + wordsToBytes platform size

                  -- convert offsets from Sp into offsets into the virtual stack

                         [ (arg, stack_bot - ByteOff offset)

                         | (NonVoid arg, offset) <- args_offsets ]

              in do

              massert isAlgCase

           -- NB: unboxed tuple cases bind the scrut binder to the same offset

           -- as one of the alt binders, so we have to remove any duplicates here:

           -- 'toAscList' takes care of sorting the result, which was previously done after the application of 'filter'.

         bitmap = intsToReverseBitmap platform bitmap_size' pointers

 lookupBCEnv_maybe :: Id -> BCEnv -> Maybe ByteOff

 idSizeW :: Platform -> Id -> WordOff

 idSizeW platform = WordOff . argRepSizeW platform . idArgRep platform

 The moving parts are relatively simple:

 * To attempt to solve the constraint completely, we just recursively

   `tcShortCutSolver`.

 Some wrinkles:

 try_inert_dicts :: TcSMode -> InertCans -> DictCt -> TcS (StopOrContinue ())

 try_inert_dicts mode inerts dict_w@(DictCt { di_ev = ev_w, di_cls = cls, di_tys = tys })

   , Just dict_i <- lookupInertDict inerts cls tys

   , let ev_i  = dictCtEvidence dict_i

         loc_i = ctEvLoc ev_i

         loc_w = ctEvLoc ev_w

   = -- There is a matching dictionary in the inert set

          -- See Note [Shortcut solving]

        ; short_cut_worked <- tryShortCutSolver (isGiven ev_i) dict_w

             , gopt Opt_SolveConstantDicts dflags

               -- Enabled by the -fsolve-constant-dicts flag

                do { residual <- solveSimpleWanteds (unitBag (CDictCan dict_w))

                   ; return (isEmptyBag residual) }

 noMatchableGivenDicts :: TcSMode -> InertSet -> CtLoc -> Class -> [TcType] -> Bool

 noMatchableGivenDicts mode inerts@(IS { inert_cans = inert_cans }) loc_w clas tys

   | TcSShortCut <- mode

   | otherwise

   = not $ anyBag matchable_given $

     findDictsByClass (inert_dicts inert_cans) clas

 -- Look up the predicate in Given quantified constraints,

 -- which are effectively just local instance declarations.

 matchLocalInst body_pred loc

          mode <- getTcSMode

        ; case mode of

            { TcSShortCut -> do { traceTcS "matchLocalInst:TcSShortCut" (ppr body_pred)

     runTcS, runTcSEarlyAbort, runTcSWithEvBinds, runTcSInerts,

     failTcS, warnTcS, addErrTcS, wrapTcS, ctLocWarnTcS,

     runTcSEqualities,

     setEvBindsTcS, setTcLevelTcS,

     emitFunDepWanteds,

        ; return res }

 -- Like nestTcS, but

 --   (b) if (but only if) success, propagate nested bindings to the caller

 -- Use only by the short-cut solver;

 --   see Note [Shortcut solving] in GHC.Tc.Solver.Dict

   = TcS $ \ env@(TcSEnv { tcs_inerts = inerts_var

                         , tcs_ev_binds = old_ev_binds_var }) ->

        ; new_wl_var       <- TcM.newTcRef emptyWorkList

        ; new_ev_binds_var <- TcM.cloneEvBindsVar old_ev_binds_var

                             , tcs_inerts   = new_inert_var

                             , tcs_worklist = new_wl_var }

        ; if null solvers then return (False, wanted) else

     do { -- Find the set of Givens to give to the plugin.

          -- See Note [Shortcut solving] in GHC.Tc.Solver.Dict

          mode <- getTcSMode

        ; given <- case mode of

 # versions of LLVM simultaneously, but that stopped working around

 # 3.5/3.6 release of LLVM.

 LlvmMinVersion=13  # inclusive

 AC_SUBST([LlvmMinVersion])

 AC_SUBST([LlvmMaxVersion])

     int bucket;

     /* Strip the boring zero bits */

     /* Mod the size of the hash table (a power of 2) */

     bucket = key & table->mask1;