[(Data.DList.maybeReturn
    :: forall a (m :: * -> *).
       Control.Monad.MonadPlus m =>
       Data.Maybe.Maybe a -> m a
  [GblId,
   Arity=2,
   Caf=NoCafRefs,
   Str=DmdType U(LLA)S,
   Unf=OtherCon []] =
      \r [$dMonadPlus eta]
          case eta of _ {
            Data.Maybe.Nothing -> Control.Monad.mzero $dMonadPlus;
            Data.Maybe.Just x ->
                case Control.Monad.$p1MonadPlus $dMonadPlus of sat_s1FS {
                  __DEFAULT -> GHC.Base.return sat_s1FS x;
                };
          };,
  [(Data.DList.maybeReturn, [])]),
 ($wa :: forall a. GHC.Prim.Int# -> a -> [a] -> [a]
  [GblId, Arity=3, Caf=NoCafRefs, Str=DmdType LLL, Unf=OtherCon []] =
      sat-only \r [ww w w1]
          let {
            $wgo [Occ=LoopBreaker] :: GHC.Prim.Int# -> [a]
            [LclId, Arity=1, Str=DmdType L, Unf=OtherCon []] =
                sat-only \r [ww1]
                    case <=# [ww1 0] of _ {
                      GHC.Types.False ->
                          let {
                            sat_s1G1 :: [a]
                            [LclId] =
                                \u [] case -# [ww1 1] of sat_s1tP { __DEFAULT -> $wgo sat_s1tP; };
                          } in  : [w sat_s1G1];
                      GHC.Types.True -> w1;
                    };
          } in  $wgo ww;,
  [($wa, [])]),
 (a :: forall a. GHC.Types.Int -> a -> [a] -> [a]
  [GblId,
   Arity=3,
   Caf=NoCafRefs,
   Str=DmdType U(L)LL,
   Unf=OtherCon []] =
      sat-only \r [w w1 w2]
          case w of _ { GHC.Types.I# ww -> $wa ww w1 w2; };,
  [(a, [])]),
 (Data.DList.replicate [InlPrag=INLINE (sat-args=2)]
    :: forall a. GHC.Types.Int -> a -> Data.DList.DList a
  [GblId,
   Arity=3,
   Caf=NoCafRefs,
   Str=DmdType U(L)LL,
   Unf=OtherCon []] =
      \r [eta_B3 eta_B2 eta_B1] a eta_B3 eta_B2 eta_B1;,
  [(Data.DList.replicate, [])]),
 (Data.DList.singleton [InlPrag=INLINE (sat-args=0)]
    :: forall a. a -> Data.DList.DList a
  [GblId, Arity=2, Caf=NoCafRefs, Str=DmdType LL, Unf=OtherCon []] =
      \r [eta_B2 eta_B1] : [eta_B2 eta_B1];,
  [(Data.DList.singleton, [])]),
 (Data.DList.empty [InlPrag=INLINE (sat-args=0)]
    :: forall a. Data.DList.DList a
  [GblId, Arity=1, Caf=NoCafRefs, Str=DmdType S, Unf=OtherCon []] =
      \r [eta_B1] GHC.Base.id eta_B1;,
  [(Data.DList.empty, [])]),
 (Data.DList.fromList [InlPrag=INLINE (sat-args=0)]
    :: forall a. [a] -> Data.DList.DList a
  [GblId, Arity=2, Caf=NoCafRefs, Str=DmdType SL, Unf=OtherCon []] =
      \r [eta_B2 eta_B1] GHC.Base.++ eta_B2 eta_B1;,
  [(Data.DList.fromList, [])]),
 (Data.DList.unDL1
    :: forall a. Data.DList.DList a -> Data.DList.DList a
  [GblId, Arity=1, Caf=NoCafRefs, Str=DmdType S, Unf=OtherCon []] =
      \r [ds] ds;,
  [(Data.DList.unDL1, [])]),
 (Data.DList.unDL :: forall a. Data.DList.DList a -> [a] -> [a]
  [GblId[[RecSel]],
   Arity=1,
   Caf=NoCafRefs,
   Str=DmdType S,
   Unf=OtherCon []] =
      \r [eta_B1] Data.DList.unDL1 eta_B1;,
  [(Data.DList.unDL, [])]),
 (Data.DList.toList [InlPrag=INLINE (sat-args=0)]
    :: forall a. Data.DList.DList a -> [a]
  [GblId,
   Arity=1,
   Caf=NoCafRefs,
   Str=DmdType C(S),
   Unf=OtherCon []] =
      \r [x] x GHC.Types.[];,
  [(Data.DList.toList, [])]),
 (Data.DList.list
    :: forall b a.
       b -> (a -> Data.DList.DList a -> b) -> Data.DList.DList a -> b
  [GblId,
   Arity=3,
   Caf=NoCafRefs,
   Str=DmdType LLC(S),
   Unf=OtherCon []] =
      \r [nill consit dl]
          case dl GHC.Types.[] of _ {
            [] -> nill;
            : x xs ->
                let {
                  sat_s1G5 :: Data.DList.DList a
                  [LclId] =
                      \r [eta_B1] GHC.Base.++ xs eta_B1;
                } in  consit x sat_s1G5;
          };,
  [(Data.DList.list, [])]),
 (lvl :: [GHC.Types.Char]
  [GblId] =
      \u [] GHC.CString.unpackCString# "Data.DList.head: empty dlist";,
  [(lvl, [])]),
 (Data.DList.head1 :: forall a. a
  [GblId, Str=DmdType b] =
      \u srt:(0,*bitmap*) [] GHC.Err.error lvl;,
  [(Data.DList.head1, [GHC.Err.error, lvl])]),
 (Data.DList.head :: forall a. Data.DList.DList a -> a
  [GblId, Arity=1, Str=DmdType C(S), Unf=OtherCon []] =
      \r srt:(0,*bitmap*) [dl]
          case dl GHC.Types.[] of _ {
            [] -> Data.DList.head1;
            : x _ -> x;
          };,
  [(Data.DList.head, [Data.DList.head1])]),
 (lvl1 :: [GHC.Types.Char]
  [GblId] =
      \u [] GHC.CString.unpackCString# "Data.DList.tail: empty dlist";,
  [(lvl1, [])]),
 (Data.DList.tail1 :: forall a. Data.DList.DList a
  [GblId, Str=DmdType b] =
      \u srt:(0,*bitmap*) [] GHC.Err.error lvl1;,
  [(Data.DList.tail1, [GHC.Err.error, lvl1])]),
 (Data.DList.tail
    :: forall a. Data.DList.DList a -> Data.DList.DList a
  [GblId, Arity=1, Str=DmdType C(S), Unf=OtherCon []] =
      \r srt:(0,*bitmap*) [dl]
          case dl GHC.Types.[] of _ {
            [] -> Data.DList.tail1;
            : _ xs -> GHC.Base.++ xs;
          };,
  [(Data.DList.tail, [Data.DList.tail1])]),
 (Data.DList.foldr [InlPrag=INLINE (sat-args=2)]
    :: forall a b. (a -> b -> b) -> b -> Data.DList.DList a -> b
  [GblId,
   Arity=3,
   Caf=NoCafRefs,
   Str=DmdType LLC(S),
   Unf=OtherCon []] =
      \r [eta eta1 eta2]
          let {
            go [Occ=LoopBreaker] :: [a] -> b
            [LclId, Arity=1, Str=DmdType S, Unf=OtherCon []] =
                sat-only \r [ds]
                    case ds of _ {
                      [] -> eta1;
                      : y ys ->
                          let {
                            sat_s1Gb :: b
                            [LclId] =
                                \u [] go ys;
                          } in  eta y sat_s1Gb;
                    };
          } in 
            case eta2 GHC.Types.[] of sat_s1Ga { __DEFAULT -> go sat_s1Ga; };,
  [(Data.DList.foldr, [])]),
 (Data.DList.apply :: forall a. Data.DList.DList a -> [a] -> [a]
  [GblId, Arity=1, Caf=NoCafRefs, Str=DmdType S, Unf=OtherCon []] =
      \r [eta_B1] Data.DList.unDL1 eta_B1;,
  [(Data.DList.apply, [])]),
 (a1 :: forall a. a -> Data.DList.DList a -> [a] -> [a]
  [GblId, Arity=3, Caf=NoCafRefs, Str=DmdType LLL, Unf=OtherCon []] =
      sat-only \r [eta eta1 eta2]
          let {
            sat_s1Gd :: [a]
            [LclId] =
                \u [] eta1 eta2;
          } in  : [eta sat_s1Gd];,
  [(a1, [])]),
 (Data.DList.cons [InlPrag=INLINE (sat-args=2)]
    :: forall a. a -> Data.DList.DList a -> Data.DList.DList a
  [GblId, Arity=3, Caf=NoCafRefs, Str=DmdType LLL, Unf=OtherCon []] =
      \r [eta_B3 eta_B2 eta_B1] a1 eta_B3 eta_B2 eta_B1;,
  [(Data.DList.cons, [])]),
 (Data.DList.unfoldr [Occ=LoopBreaker]
    :: forall b a.
       (b -> Data.Maybe.Maybe (a, b)) -> b -> Data.DList.DList a
  [GblId,
   Arity=2,
   Caf=NoCafRefs,
   Str=DmdType C(S)L,
   Unf=OtherCon []] =
      \r [pf b]
          case pf b of _ {
            Data.Maybe.Nothing -> GHC.Base.id;
            Data.Maybe.Just ds ->
                case ds of _ {
                  (,) a6 b' ->
                      let {
                        a7 [Dmd=Just L] :: Data.DList.DList a
                        [LclId, Str=DmdType] =
                            \u [] Data.DList.unfoldr pf b'; } in
                      let {
                        sat_s1Gf :: [a] -> [a]
                        [LclId] =
                            \r [x]
                                let {
                                  sat_s1v9 :: [a]
                                  [LclId] =
                                      \u [] a7 x;
                                } in  : [a6 sat_s1v9];
                      } in  sat_s1Gf;
                };
          };,
  [(Data.DList.unfoldr, [])]),
 (Data.DList.map [InlPrag=INLINE (sat-args=1)]
    :: forall a b. (a -> b) -> Data.DList.DList a -> Data.DList.DList b
  [GblId,
   Arity=2,
   Caf=NoCafRefs,
   Str=DmdType LC(S),
   Unf=OtherCon []] =
      \r [eta eta1]
          let {
            go [Occ=LoopBreaker] :: [a] -> Data.DList.DList b
            [LclId, Arity=1, Str=DmdType S, Unf=OtherCon []] =
                sat-only \r [ds]
                    case ds of _ {
                      [] -> GHC.Base.id;
                      : y ys ->
                          let {
                            a6 [Dmd=Just L] :: Data.DList.DList b
                            [LclId, Str=DmdType] =
                                \u [] go ys; } in
                          let {
                            x [Dmd=Just L] :: b
                            [LclId, Str=DmdType] =
                                \u [] eta y; } in
                          let {
                            sat_s1Gi :: [b] -> [b]
                            [LclId] =
                                \r [x1]
                                    let {
                                      sat_s1vu :: [b]
                                      [LclId] =
                                          \u [] a6 x1;
                                    } in  : [x sat_s1vu];
                          } in  sat_s1Gi;
                    };
          } in 
            case eta1 GHC.Types.[] of sat_s1Gh { __DEFAULT -> go sat_s1Gh; };,
  [(Data.DList.map, [])]),
 (a2 :: forall a. Data.DList.DList a -> a -> [a] -> [a]
  [GblId,
   Arity=3,
   Caf=NoCafRefs,
   Str=DmdType C(S)LL,
   Unf=OtherCon []] =
      sat-only \r [eta eta1 eta2]
          let {
            sat_s1Gk :: [a]
            [LclId] =
                NO_CCS :! [eta1 eta2];
          } in  eta sat_s1Gk;,
  [(a2, [])]),
 (Data.DList.snoc [InlPrag=INLINE (sat-args=2)]
    :: forall a. Data.DList.DList a -> a -> Data.DList.DList a
  [GblId,
   Arity=3,
   Caf=NoCafRefs,
   Str=DmdType C(S)LL,
   Unf=OtherCon []] =
      \r [eta_B3 eta_B2 eta_B1] a2 eta_B3 eta_B2 eta_B1;,
  [(Data.DList.snoc, [])]),
 (a3
    :: forall a. Data.DList.DList a -> Data.DList.DList a -> [a] -> [a]
  [GblId,
   Arity=3,
   Caf=NoCafRefs,
   Str=DmdType C(S)LL,
   Unf=OtherCon []] =
      sat-only \r [eta eta1 eta2]
          let {
            sat_s1Gl :: [a]
            [LclId] =
                \u [] eta1 eta2;
          } in  eta sat_s1Gl;,
  [(a3, [])]),
 (Data.DList.append [InlPrag=INLINE (sat-args=2)]
    :: forall a.
       Data.DList.DList a -> Data.DList.DList a -> Data.DList.DList a
  [GblId,
   Arity=3,
   Caf=NoCafRefs,
   Str=DmdType C(S)LL,
   Unf=OtherCon []] =
      \r [eta_B3 eta_B2 eta_B1] a3 eta_B3 eta_B2 eta_B1;,
  [(Data.DList.append, [])]),
 (a4 :: forall a. [Data.DList.DList a] -> [a] -> [a]
  [GblId, Arity=2, Caf=NoCafRefs, Str=DmdType SL, Unf=OtherCon []] =
      sat-only \r [ds eta]
          case ds of _ {
            [] -> eta;
            : y ys ->
                let {
                  sat_s1Gn :: [a]
                  [LclId] =
                      \u [] a4 ys eta;
                } in  y sat_s1Gn;
          };,
  [(a4, [])]),
 (Data.DList.concat [InlPrag=INLINE (sat-args=0)]
    :: forall a. [Data.DList.DList a] -> Data.DList.DList a
  [GblId, Arity=2, Caf=NoCafRefs, Str=DmdType SL, Unf=OtherCon []] =
      \r [eta_B2 eta_B1] a4 eta_B2 eta_B1;,
  [(Data.DList.concat, [])]),
 (Data.DList.$fEqDList_$c==
    :: forall a.
       GHC.Classes.Eq a =>
       Data.DList.DList a -> Data.DList.DList a -> GHC.Types.Bool
  [GblId,
   Arity=3,
   Caf=NoCafRefs,
   Str=DmdType LC(S)C(S),
   Unf=OtherCon []] =
      \r [$dEq eta eta1]
          case eta1 GHC.Types.[] of sat_s1Go {
            __DEFAULT ->
                case eta GHC.Types.[] of sat_s1Gp {
                  __DEFAULT -> GHC.Classes.$fEq[]_$c== $dEq sat_s1Gp sat_s1Go;
                };
          };,
  [(Data.DList.$fEqDList_$c==, [])]),
 (Data.DList.$fEqDList_$c/= [InlPrag=INLINE (sat-args=2)]
    :: forall a.
       GHC.Classes.Eq a =>
       Data.DList.DList a -> Data.DList.DList a -> GHC.Types.Bool
  [GblId,
   Arity=3,
   Caf=NoCafRefs,
   Str=DmdType LC(S)C(S),
   Unf=OtherCon []] =
      \r [$dEq eta eta1]
          case eta1 GHC.Types.[] of sat_s1Gq {
            __DEFAULT ->
                case eta GHC.Types.[] of sat_s1Gr {
                  __DEFAULT ->
                      case GHC.Classes.$fEq[]_$c== $dEq sat_s1Gr sat_s1Gq of _ {
                        GHC.Types.False -> GHC.Types.True [];
                        GHC.Types.True -> GHC.Types.False [];
                      };
                };
          };,
  [(Data.DList.$fEqDList_$c/=, [])]),
 (Data.DList.$fEqDList [InlPrag=[ALWAYS] CONLIKE]
    :: forall a.
       GHC.Classes.Eq a =>
       GHC.Classes.Eq (Data.DList.DList a)
  [GblId[DFunId],
   Arity=1,
   Caf=NoCafRefs,
   Str=DmdType Lm,
   Unf=OtherCon []] =
      \r [$dEq]
          let {
            sat_s1Gt
              :: Data.DList.DList a -> Data.DList.DList a -> GHC.Types.Bool
            [LclId] =
                \r [eta_B2 eta_B1]
                    Data.DList.$fEqDList_$c/= $dEq eta_B2 eta_B1; } in
          let {
            sat_s1Gu
              :: Data.DList.DList a -> Data.DList.DList a -> GHC.Types.Bool
            [LclId] =
                \r [eta_B2 eta_B1] Data.DList.$fEqDList_$c== $dEq eta_B2 eta_B1;
          } in  GHC.Classes.D:Eq [sat_s1Gu sat_s1Gt];,
  [(Data.DList.$fEqDList, [])]),
 (Data.DList.$fOrdDList_$ccompare
    :: forall a.
       (GHC.Classes.Eq (Data.DList.DList a), GHC.Classes.Ord a) =>
       Data.DList.DList a -> Data.DList.DList a -> GHC.Types.Ordering
  [GblId,
   Arity=4,
   Caf=NoCafRefs,
   Str=DmdType ALC(S)C(S),
   Unf=OtherCon []] =
      \r [$dEq $dOrd x y]
          case y GHC.Types.[] of sat_s1Gv {
            __DEFAULT ->
                case x GHC.Types.[] of sat_s1Gw {
                  __DEFAULT -> GHC.Classes.$w$ccompare14 $dOrd sat_s1Gw sat_s1Gv;
                };
          };,
  [(Data.DList.$fOrdDList_$ccompare, [])]),
 (Data.DList.$fOrdDList_$c<=
    :: forall a.
       (GHC.Classes.Eq (Data.DList.DList a), GHC.Classes.Ord a) =>
       Data.DList.DList a -> Data.DList.DList a -> GHC.Types.Bool
  [GblId,
   Arity=4,
   Caf=NoCafRefs,
   Str=DmdType ALC(S)C(S),
   Unf=OtherCon []] =
      \r [$dEq $dOrd x y]
          case y GHC.Types.[] of sat_s1Gx {
            __DEFAULT ->
                case x GHC.Types.[] of sat_s1Gy {
                  __DEFAULT ->
                      case GHC.Classes.$w$ccompare14 $dOrd sat_s1Gy sat_s1Gx of _ {
                        __DEFAULT -> GHC.Types.True [];
                        GHC.Types.GT -> GHC.Types.False [];
                      };
                };
          };,
  [(Data.DList.$fOrdDList_$c<=, [])]),
 (Data.DList.$fOrdDList_$cmax
    :: forall a.
       (GHC.Classes.Eq (Data.DList.DList a), GHC.Classes.Ord a) =>
       Data.DList.DList a -> Data.DList.DList a -> Data.DList.DList a
  [GblId,
   Arity=4,
   Caf=NoCafRefs,
   Str=DmdType ALC(S)C(S),
   Unf=OtherCon []] =
      \r [$dEq $dOrd x y]
          case y GHC.Types.[] of sat_s1GA {
            __DEFAULT ->
                case x GHC.Types.[] of sat_s1GB {
                  __DEFAULT ->
                      case GHC.Classes.$w$ccompare14 $dOrd sat_s1GB sat_s1GA of _ {
                        __DEFAULT -> y;
                        GHC.Types.GT -> x;
                      };
                };
          };,
  [(Data.DList.$fOrdDList_$cmax, [])]),
 (Data.DList.$fOrdDList_$cmin
    :: forall a.
       (GHC.Classes.Eq (Data.DList.DList a), GHC.Classes.Ord a) =>
       Data.DList.DList a -> Data.DList.DList a -> Data.DList.DList a
  [GblId,
   Arity=4,
   Caf=NoCafRefs,
   Str=DmdType ALC(S)C(S),
   Unf=OtherCon []] =
      \r [$dEq $dOrd x y]
          case y GHC.Types.[] of sat_s1GD {
            __DEFAULT ->
                case x GHC.Types.[] of sat_s1GE {
                  __DEFAULT ->
                      case GHC.Classes.$w$ccompare14 $dOrd sat_s1GE sat_s1GD of _ {
                        __DEFAULT -> x;
                        GHC.Types.GT -> y;
                      };
                };
          };,
  [(Data.DList.$fOrdDList_$cmin, [])]),
 (Data.DList.$fOrdDList_$c>
    :: forall a.
       (GHC.Classes.Eq (Data.DList.DList a), GHC.Classes.Ord a) =>
       Data.DList.DList a -> Data.DList.DList a -> GHC.Types.Bool
  [GblId,
   Arity=4,
   Caf=NoCafRefs,
   Str=DmdType ALC(S)C(S),
   Unf=OtherCon []] =
      \r [$dEq $dOrd x y]
          case y GHC.Types.[] of sat_s1GG {
            __DEFAULT ->
                case x GHC.Types.[] of sat_s1GH {
                  __DEFAULT ->
                      case GHC.Classes.$w$ccompare14 $dOrd sat_s1GH sat_s1GG of _ {
                        __DEFAULT -> GHC.Types.False [];
                        GHC.Types.GT -> GHC.Types.True [];
                      };
                };
          };,
  [(Data.DList.$fOrdDList_$c>, [])]),
 (Data.DList.$fOrdDList_$c>=
    :: forall a.
       (GHC.Classes.Eq (Data.DList.DList a), GHC.Classes.Ord a) =>
       Data.DList.DList a -> Data.DList.DList a -> GHC.Types.Bool
  [GblId,
   Arity=4,
   Caf=NoCafRefs,
   Str=DmdType ALC(S)C(S),
   Unf=OtherCon []] =
      \r [$dEq $dOrd x y]
          case y GHC.Types.[] of sat_s1GJ {
            __DEFAULT ->
                case x GHC.Types.[] of sat_s1GK {
                  __DEFAULT ->
                      case GHC.Classes.$w$ccompare14 $dOrd sat_s1GK sat_s1GJ of _ {
                        __DEFAULT -> GHC.Types.True [];
                        GHC.Types.LT -> GHC.Types.False [];
                      };
                };
          };,
  [(Data.DList.$fOrdDList_$c>=, [])]),
 (Data.DList.$fOrdDList_$c<
    :: forall a.
       (GHC.Classes.Eq (Data.DList.DList a), GHC.Classes.Ord a) =>
       Data.DList.DList a -> Data.DList.DList a -> GHC.Types.Bool
  [GblId,
   Arity=4,
   Caf=NoCafRefs,
   Str=DmdType ALC(S)C(S),
   Unf=OtherCon []] =
      \r [$dEq $dOrd x y]
          case y GHC.Types.[] of sat_s1GM {
            __DEFAULT ->
                case x GHC.Types.[] of sat_s1GN {
                  __DEFAULT ->
                      case GHC.Classes.$w$ccompare14 $dOrd sat_s1GN sat_s1GM of _ {
                        __DEFAULT -> GHC.Types.False [];
                        GHC.Types.LT -> GHC.Types.True [];
                      };
                };
          };,
  [(Data.DList.$fOrdDList_$c<, [])]),
 (Data.DList.$fOrdDList [InlPrag=[ALWAYS] CONLIKE]
    :: forall a.
       (GHC.Classes.Eq (Data.DList.DList a), GHC.Classes.Ord a) =>
       GHC.Classes.Ord (Data.DList.DList a)
  [GblId[DFunId[1]],
   Arity=2,
   Caf=NoCafRefs,
   Str=DmdType LLm,
   Unf=OtherCon []] =
      \r [$dEq $dOrd]
          let {
            sat_s1GR
              :: Data.DList.DList a -> Data.DList.DList a -> Data.DList.DList a
            [LclId] =
                \r [eta_B2 eta_B1]
                    Data.DList.$fOrdDList_$cmin $dEq $dOrd eta_B2 eta_B1; } in
          let {
            sat_s1GS
              :: Data.DList.DList a -> Data.DList.DList a -> Data.DList.DList a
            [LclId] =
                \r [eta_B2 eta_B1]
                    Data.DList.$fOrdDList_$cmax $dEq $dOrd eta_B2 eta_B1; } in
          let {
            sat_s1GT
              :: Data.DList.DList a -> Data.DList.DList a -> GHC.Types.Bool
            [LclId] =
                \r [eta_B2 eta_B1]
                    Data.DList.$fOrdDList_$c<= $dEq $dOrd eta_B2 eta_B1; } in
          let {
            sat_s1GU
              :: Data.DList.DList a -> Data.DList.DList a -> GHC.Types.Bool
            [LclId] =
                \r [eta_B2 eta_B1]
                    Data.DList.$fOrdDList_$c> $dEq $dOrd eta_B2 eta_B1; } in
          let {
            sat_s1GV
              :: Data.DList.DList a -> Data.DList.DList a -> GHC.Types.Bool
            [LclId] =
                \r [eta_B2 eta_B1]
                    Data.DList.$fOrdDList_$c>= $dEq $dOrd eta_B2 eta_B1; } in
          let {
            sat_s1GW
              :: Data.DList.DList a -> Data.DList.DList a -> GHC.Types.Bool
            [LclId] =
                \r [eta_B2 eta_B1]
                    Data.DList.$fOrdDList_$c< $dEq $dOrd eta_B2 eta_B1; } in
          let {
            sat_s1GX
              :: Data.DList.DList a -> Data.DList.DList a -> GHC.Types.Ordering
            [LclId] =
                \r [x y]
                    case y GHC.Types.[] of sat_s1GP {
                      __DEFAULT ->
                          case x GHC.Types.[] of sat_s1GQ {
                            __DEFAULT -> GHC.Classes.$w$ccompare14 $dOrd sat_s1GQ sat_s1GP;
                          };
                    };
          } in 
            GHC.Classes.D:Ord [$dEq
                               sat_s1GX
                               sat_s1GW
                               sat_s1GV
                               sat_s1GU
                               sat_s1GT
                               sat_s1GS
                               sat_s1GR];,
  [(Data.DList.$fOrdDList, [])]),
 (Data.DList.$fReadDList4 :: GHC.Types.Int
  [GblId, Caf=NoCafRefs, Str=DmdType m, Unf=OtherCon []] =
      NO_CCS GHC.Types.I#! [10];,
  [(Data.DList.$fReadDList4, [])]),
 (Data.DList.$fReadDList3 :: [GHC.Types.Char]
  [GblId, Str=DmdType] =
      \u [] GHC.CString.unpackCString# "fromList";,
  [(Data.DList.$fReadDList3, [])]),
 (Data.DList.$fReadDList2
    :: forall a.
       GHC.Read.Read a =>
       Text.ParserCombinators.ReadPrec.Prec
       -> Text.ParserCombinators.ReadP.ReadP (Data.DList.DList a)
  [GblId, Arity=1, Str=DmdType L, Unf=OtherCon []] =
      \r srt:(0,*bitmap*) [$dRead]
          let {
            ds :: Text.ParserCombinators.ReadPrec.ReadPrec [a]
            [LclId, Str=DmdType] =
                \u [] GHC.Read.readListPrec $dRead; } in
          let {
            lvl3
              :: forall b.
                 (Data.DList.DList a -> Text.ParserCombinators.ReadP.P b)
                 -> Text.ParserCombinators.ReadP.P b
            [LclId, Arity=1, Unf=OtherCon []] =
                \r srt:(1,*bitmap*) [eta]
                    let {
                      lvl4 :: Text.ParserCombinators.ReadP.P b
                      [LclId] =
                          \u []
                              let {
                                sat_s1xY :: [a] -> Text.ParserCombinators.ReadP.P b
                                [LclId] =
                                    \r [a6]
                                        let {
                                          sat_s1GY :: Data.DList.DList a
                                          [LclId] =
                                              \r [eta_B1] GHC.Base.++ a6 eta_B1;
                                        } in  eta sat_s1GY;
                              } in  ds Data.DList.$fReadDList4 sat_s1xY; } in
                    let {
                      sat_s1GZ
                        :: Text.Read.Lex.Lexeme -> Text.ParserCombinators.ReadP.P b
                      [LclId] =
                          \r srt:(2,*bitmap*) [a6]
                              case a6 of _ {
                                __DEFAULT -> Text.ParserCombinators.ReadP.Fail [];
                                Text.Read.Lex.Ident ds1 ->
                                    case GHC.Base.eqString ds1 Data.DList.$fReadDList3 of _ {
                                      GHC.Types.False -> Text.ParserCombinators.ReadP.Fail [];
                                      GHC.Types.True -> lvl4;
                                    };
                              };
                    } in  Text.Read.Lex.lex1 sat_s1GZ; } in
          let {
            sat_s1H0
              :: Text.ParserCombinators.ReadPrec.ReadPrec (Data.DList.DList a)
            [LclId] =
                \r [c]
                    case c of _ {
                      GHC.Types.I# x ->
                          case <=# [x 10] of _ {
                            GHC.Types.False -> Text.ParserCombinators.ReadP.pfail1;
                            GHC.Types.True -> lvl3;
                          };
                    };
          } in  GHC.Read.parens1 sat_s1H0;,
  [(Data.DList.$fReadDList2,
    [GHC.Read.parens1, Text.Read.Lex.lex1, Data.DList.$fReadDList3])]),
 (Data.DList.$fReadDList_$creadPrec
    :: forall a.
       GHC.Read.Read a =>
       Text.ParserCombinators.ReadPrec.ReadPrec (Data.DList.DList a)
  [GblId, Arity=1, Str=DmdType L, Unf=OtherCon []] =
      \r srt:(0,*bitmap*) [eta_B1] Data.DList.$fReadDList2 eta_B1;,
  [(Data.DList.$fReadDList_$creadPrec, [Data.DList.$fReadDList2])]),
 (Data.DList.$fReadDList_$creadList
    :: forall a.
       GHC.Read.Read a =>
       Text.ParserCombinators.ReadP.ReadS [Data.DList.DList a]
  [GblId, Arity=1, Str=DmdType L, Unf=OtherCon []] =
      \r srt:(0,*bitmap*) [$dRead]
          let {
            sat_s1H5 :: Text.ParserCombinators.ReadP.P [Data.DList.DList a]
            [LclId] =
                \u srt:(0,*bitmap*) []
                    let {
                      sat_s1yi
                        :: Text.ParserCombinators.ReadPrec.ReadPrec (Data.DList.DList a)
                      [LclId] =
                          \u srt:(1,*bitmap*) [] Data.DList.$fReadDList2 $dRead;
                    } in 
                      GHC.Read.$wa
                          sat_s1yi Text.ParserCombinators.ReadP.$fMonadP_$creturn;
          } in  Text.ParserCombinators.ReadP.run sat_s1H5;,
  [(Data.DList.$fReadDList_$creadList,
    [GHC.Read.$wa, Data.DList.$fReadDList2])]),
 (Data.DList.$fReadDList_$creadsPrec
    :: forall a.
       GHC.Read.Read a =>
       GHC.Types.Int
       -> Text.ParserCombinators.ReadP.ReadS (Data.DList.DList a)
  [GblId, Arity=1, Str=DmdType L, Unf=OtherCon []] =
      \r srt:(0,*bitmap*) [$dRead]
          let {
            a6 [Dmd=Just L]
              :: Text.ParserCombinators.ReadPrec.Prec
                 -> Text.ParserCombinators.ReadP.ReadP (Data.DList.DList a)
            [LclId, Str=DmdType] =
                \u srt:(0,*bitmap*) [] Data.DList.$fReadDList2 $dRead; } in
          let {
            sat_s1H6
              :: GHC.Types.Int
                 -> Text.ParserCombinators.ReadP.ReadS (Data.DList.DList a)
            [LclId] =
                \r [n]
                    let {
                      sat_s1yr :: Text.ParserCombinators.ReadP.P (Data.DList.DList a)
                      [LclId] =
                          \u [] a6 n Text.ParserCombinators.ReadP.$fMonadP_$creturn;
                    } in  Text.ParserCombinators.ReadP.run sat_s1yr;
          } in  sat_s1H6;,
  [(Data.DList.$fReadDList_$creadsPrec, [Data.DList.$fReadDList2])]),
 (Data.DList.$fReadDList1
    :: forall a.
       GHC.Read.Read a =>
       Text.ParserCombinators.ReadPrec.Prec
       -> forall b.
          ([Data.DList.DList a] -> Text.ParserCombinators.ReadP.P b)
          -> Text.ParserCombinators.ReadP.P b
  [GblId, Arity=3, Str=DmdType LAL, Unf=OtherCon []] =
      \r srt:(0,*bitmap*) [$dRead eta eta1]
          let {
            sat_s1H7
              :: Text.ParserCombinators.ReadPrec.ReadPrec (Data.DList.DList a)
            [LclId] =
                \u srt:(1,*bitmap*) [] Data.DList.$fReadDList2 $dRead;
          } in  GHC.Read.$wa sat_s1H7 eta1;,
  [(Data.DList.$fReadDList1,
    [GHC.Read.$wa, Data.DList.$fReadDList2])]),
 (Data.DList.$fReadDList_$creadListPrec
    :: forall a.
       GHC.Read.Read a =>
       Text.ParserCombinators.ReadPrec.ReadPrec [Data.DList.DList a]
  [GblId, Arity=3, Str=DmdType LAL, Unf=OtherCon []] =
      \r srt:(0,*bitmap*) [eta_B3 eta_B2 eta_B1]
          Data.DList.$fReadDList1 eta_B3 eta_B2 eta_B1;,
  [(Data.DList.$fReadDList_$creadListPrec,
    [Data.DList.$fReadDList1])]),
 (Data.DList.$fReadDList [InlPrag=[ALWAYS] CONLIKE]
    :: forall a. GHC.Read.Read a => GHC.Read.Read (Data.DList.DList a)
  [GblId[DFunId], Arity=1, Str=DmdType Lm, Unf=OtherCon []] =
      \r srt:(0,*bitmap*) [$dRead]
          let {
            sat_s1H8
              :: Text.ParserCombinators.ReadPrec.ReadPrec [Data.DList.DList a]
            [LclId] =
                \r srt:(0,*bitmap*) [eta_B2 eta_B1]
                    Data.DList.$fReadDList1 $dRead eta_B2 eta_B1; } in
          let {
            sat_s1H9
              :: Text.ParserCombinators.ReadPrec.ReadPrec (Data.DList.DList a)
            [LclId] =
                \u srt:(1,*bitmap*) [] Data.DList.$fReadDList2 $dRead; } in
          let {
            sat_s1Ha :: Text.ParserCombinators.ReadP.ReadS [Data.DList.DList a]
            [LclId] =
                \u srt:(2,*bitmap*) []
                    Data.DList.$fReadDList_$creadList $dRead; } in
          let {
            sat_s1Hb
              :: GHC.Types.Int
                 -> Text.ParserCombinators.ReadP.ReadS (Data.DList.DList a)
            [LclId] =
                \u srt:(3,*bitmap*) [] Data.DList.$fReadDList_$creadsPrec $dRead;
          } in  GHC.Read.D:Read [sat_s1Hb sat_s1Ha sat_s1H9 sat_s1H8];,
  [(Data.DList.$fReadDList,
    [Data.DList.$fReadDList1, Data.DList.$fReadDList2,
     Data.DList.$fReadDList_$creadList, Data.DList.$fReadDList2])]),
 (Data.DList.$fShowDList1 :: [GHC.Types.Char]
  [GblId, Str=DmdType] =
      \u [] GHC.CString.unpackCString# "fromList ";,
  [(Data.DList.$fShowDList1, [])]),
 (Data.DList.$w$cshowsPrec
    :: forall a.
       GHC.Show.Show a =>
       GHC.Prim.Int# -> Data.DList.DList a -> GHC.Show.ShowS
  [GblId, Arity=3, Str=DmdType LLL, Unf=OtherCon []] =
      \r srt:(0,*bitmap*) [w ww w1]
          let {
            g [Dmd=Just L] :: GHC.Base.String -> GHC.Base.String
            [LclId, Str=DmdType] =
                \u []
                    let {
                      sat_s1yN :: [a]
                      [LclId] =
                          \u [] w1 GHC.Types.[];
                    } in  GHC.Show.showList w sat_s1yN;
          } in 
            case ># [ww 10] of _ {
              GHC.Types.False ->
                  let {
                    sat_s1Hc :: GHC.Base.String -> [GHC.Types.Char]
                    [LclId] =
                        \r srt:(0,*bitmap*) [x]
                            let {
                              sat_s1yU :: [GHC.Types.Char]
                              [LclId] =
                                  \u [] g x;
                            } in  GHC.Base.++ Data.DList.$fShowDList1 sat_s1yU;
                  } in  sat_s1Hc;
              GHC.Types.True ->
                  let {
                    sat_s1Hd :: GHC.Base.String -> [GHC.Types.Char]
                    [LclId] =
                        \r srt:(0,*bitmap*) [x]
                            let {
                              sat_s1z3 :: [GHC.Types.Char]
                              [LclId] =
                                  \u srt:(0,*bitmap*) []
                                      let {
                                        sat_s1z1 :: [GHC.Types.Char]
                                        [LclId] =
                                            \u []
                                                let {
                                                  sat_s1yZ :: GHC.Base.String
                                                  [LclId] =
                                                      NO_CCS :! [GHC.Show.shows10 x];
                                                } in  g sat_s1yZ;
                                      } in  GHC.Base.++ Data.DList.$fShowDList1 sat_s1z1;
                            } in  : [GHC.Show.shows11 sat_s1z3];
                  } in  sat_s1Hd;
            };,
  [(Data.DList.$w$cshowsPrec, [Data.DList.$fShowDList1])]),
 (Data.DList.$fShowDList_$cshowsPrec [InlPrag=INLINE[0]]
    :: forall a.
       GHC.Show.Show a =>
       GHC.Types.Int -> Data.DList.DList a -> GHC.Show.ShowS
  [GblId, Arity=3, Str=DmdType LU(L)L, Unf=OtherCon []] =
      \r srt:(0,*bitmap*) [w w1 w2]
          case w1 of _ {
            GHC.Types.I# ww -> Data.DList.$w$cshowsPrec w ww w2;
          };,
  [(Data.DList.$fShowDList_$cshowsPrec, [Data.DList.$fShowDList1])]),
 (Data.DList.$fShowDList_$cshowList
    :: forall a.
       GHC.Show.Show a =>
       [Data.DList.DList a] -> GHC.Show.ShowS
  [GblId, Arity=3, Str=DmdType LSL, Unf=OtherCon []] =
      \r srt:(0,*bitmap*) [$dShow eta eta1]
          let {
            sat_s1Hg :: Data.DList.DList a -> GHC.Show.ShowS
            [LclId] =
                \r srt:(0,*bitmap*) [w] Data.DList.$w$cshowsPrec $dShow 0 w;
          } in  GHC.Show.showList__ sat_s1Hg eta eta1;,
  [(Data.DList.$fShowDList_$cshowList, [Data.DList.$fShowDList1])]),
 (Data.DList.$fShowDList_$cshow
    :: forall a.
       GHC.Show.Show a =>
       Data.DList.DList a -> GHC.Base.String
  [GblId, Arity=2, Str=DmdType LL, Unf=OtherCon []] =
      \r srt:(0,*bitmap*) [$dShow x]
          Data.DList.$w$cshowsPrec $dShow 0 x GHC.Types.[];,
  [(Data.DList.$fShowDList_$cshow, [Data.DList.$fShowDList1])]),
 (Data.DList.$fShowDList [InlPrag=[ALWAYS] CONLIKE]
    :: forall a. GHC.Show.Show a => GHC.Show.Show (Data.DList.DList a)
  [GblId[DFunId], Arity=1, Str=DmdType Lm, Unf=OtherCon []] =
      \r srt:(0,*bitmap*) [$dShow]
          let {
            sat_s1Hh :: [Data.DList.DList a] -> GHC.Show.ShowS
            [LclId] =
                \r srt:(0,*bitmap*) [eta_B2 eta_B1]
                    Data.DList.$fShowDList_$cshowList $dShow eta_B2 eta_B1; } in
          let {
            sat_s1Hi :: Data.DList.DList a -> GHC.Base.String
            [LclId] =
                \r srt:(1,*bitmap*) [eta_B1]
                    Data.DList.$fShowDList_$cshow $dShow eta_B1; } in
          let {
            sat_s1Hj :: GHC.Types.Int -> Data.DList.DList a -> GHC.Show.ShowS
            [LclId] =
                \r srt:(2,*bitmap*) [eta_B2 eta_B1]
                    Data.DList.$fShowDList_$cshowsPrec $dShow eta_B2 eta_B1;
          } in  GHC.Show.D:Show [sat_s1Hj sat_s1Hi sat_s1Hh];,
  [(Data.DList.$fShowDList,
    [Data.DList.$fShowDList1, Data.DList.$fShowDList1,
     Data.DList.$fShowDList1])]),
 (Data.DList.$fMonoidDList1 [Occ=LoopBreaker]
    :: forall a. [Data.DList.DList a] -> [a] -> [a]
  [GblId, Arity=2, Caf=NoCafRefs, Str=DmdType SL, Unf=OtherCon []] =
      \r [ds eta]
          case ds of _ {
            [] -> eta;
            : y ys ->
                let {
                  sat_s1Hl :: [a]
                  [LclId] =
                      \u [] Data.DList.$fMonoidDList1 ys eta;
                } in  y sat_s1Hl;
          };,
  [(Data.DList.$fMonoidDList1, [])]),
 (Data.DList.$fMonoidDList_$cmconcat
    :: forall a. [Data.DList.DList a] -> Data.DList.DList a
  [GblId, Arity=2, Caf=NoCafRefs, Str=DmdType SL, Unf=OtherCon []] =
      \r [eta_B2 eta_B1] Data.DList.$fMonoidDList1 eta_B2 eta_B1;,
  [(Data.DList.$fMonoidDList_$cmconcat, [])]),
 (Data.DList.$fMonoidDList [InlPrag=[ALWAYS] CONLIKE]
    :: forall a. Data.Monoid.Monoid (Data.DList.DList a)
  [GblId[DFunId], Caf=NoCafRefs, Str=DmdType m, Unf=OtherCon []] =
      NO_CCS Data.Monoid.D:Monoid! [GHC.Base.id
                                    Data.DList.append
                                    Data.DList.$fMonoidDList1];,
  [(Data.DList.$fMonoidDList, [])]),
 (Data.DList.$fFunctorDList_$cfmap [InlPrag=INLINE (sat-args=0)]
    :: forall a b. (a -> b) -> Data.DList.DList a -> Data.DList.DList b
  [GblId,
   Arity=2,
   Caf=NoCafRefs,
   Str=DmdType LC(S),
   Unf=OtherCon []] =
      \r [eta_B2 eta_B1] Data.DList.map eta_B2 eta_B1;,
  [(Data.DList.$fFunctorDList_$cfmap, [])]),
 (Data.DList.$fFunctorDList_$c<$
    :: forall a b. a -> Data.DList.DList b -> Data.DList.DList a
  [GblId, Arity=2, Caf=NoCafRefs, Str=DmdType LL, Unf=OtherCon []] =
      \r [x eta]
          let {
            a6 [Occ=LoopBreaker] :: [b] -> [a] -> [a]
            [LclId, Arity=2, Str=DmdType SL, Unf=OtherCon []] =
                \r [ds eta1]
                    case ds of _ {
                      [] -> eta1;
                      : y ys ->
                          let {
                            sat_s1Hn :: [a]
                            [LclId] =
                                \u [] a6 ys eta1;
                          } in  : [x sat_s1Hn];
                    }; } in
          let {
            sat_s1Hm :: [b]
            [LclId] =
                \u [] eta GHC.Types.[];
          } in  a6 sat_s1Hm;,
  [(Data.DList.$fFunctorDList_$c<$, [])]),
 (Data.DList.$fFunctorDList [InlPrag=[ALWAYS] CONLIKE]
    :: GHC.Base.Functor Data.DList.DList
  [GblId[DFunId], Caf=NoCafRefs, Str=DmdType m, Unf=OtherCon []] =
      NO_CCS GHC.Base.D:Functor! [Data.DList.map
                                  Data.DList.$fFunctorDList_$c<$];,
  [(Data.DList.$fFunctorDList, [])]),
 (a5 :: forall a. GHC.Base.String -> [a] -> [a]
  [GblId, Arity=2, Caf=NoCafRefs, Str=DmdType AS, Unf=OtherCon []] =
      sat-only \r [eta eta1] eta1;,
  [(a5, [])]),
 (Data.DList.$fMonadDList_$cfail [InlPrag=INLINE (sat-args=1)]
    :: forall a. GHC.Base.String -> Data.DList.DList a
  [GblId, Arity=2, Caf=NoCafRefs, Str=DmdType AS, Unf=OtherCon []] =
      \r [eta_B2 eta_B1] a5 eta_B2 eta_B1;,
  [(Data.DList.$fMonadDList_$cfail, [])]),
 (Data.DList.$fApplicativeDList_$creturn [InlPrag=INLINE (sat-args=1)]
    :: forall a. a -> Data.DList.DList a
  [GblId, Arity=2, Caf=NoCafRefs, Str=DmdType LL, Unf=OtherCon []] =
      \r [eta_B2 eta_B1] : [eta_B2 eta_B1];,
  [(Data.DList.$fApplicativeDList_$creturn, [])]),
 (Data.DList.$fMonadDList_$c>>= [InlPrag=INLINE (sat-args=2)]
    :: forall a b.
       Data.DList.DList a
       -> (a -> Data.DList.DList b) -> Data.DList.DList b
  [GblId,
   Arity=2,
   Caf=NoCafRefs,
   Str=DmdType C(S)L,
   Unf=OtherCon []] =
      \r [eta eta1]
          let {
            go [Occ=LoopBreaker] :: [a] -> Data.DList.DList b
            [LclId, Arity=1, Str=DmdType S, Unf=OtherCon []] =
                sat-only \r [ds]
                    case ds of _ {
                      [] -> GHC.Base.id;
                      : y ys ->
                          let {
                            a6 [Dmd=Just L] :: Data.DList.DList b
                            [LclId, Str=DmdType] =
                                \u [] go ys; } in
                          let {
                            a7 [Dmd=Just L] :: Data.DList.DList b
                            [LclId, Str=DmdType] =
                                \u [] eta1 y; } in
                          let {
                            sat_s1Hr :: [b] -> [b]
                            [LclId] =
                                \r [x]
                                    let {
                                      sat_s1Aj :: [b]
                                      [LclId] =
                                          \u [] a6 x;
                                    } in  a7 sat_s1Aj;
                          } in  sat_s1Hr;
                    };
          } in 
            case eta GHC.Types.[] of sat_s1Hq { __DEFAULT -> go sat_s1Hq; };,
  [(Data.DList.$fMonadDList_$c>>=, [])]),
 (Data.DList.$fMonadDList_$c>> [InlPrag=INLINE (sat-args=2)]
    :: forall a b.
       Data.DList.DList a -> Data.DList.DList b -> Data.DList.DList b
  [GblId, Arity=2, Caf=NoCafRefs, Str=DmdType LL, Unf=OtherCon []] =
      \r [eta eta1]
          let {
            a6 [Occ=LoopBreaker] :: [a] -> [b] -> [b]
            [LclId, Arity=2, Str=DmdType SL, Unf=OtherCon []] =
                \r [ds eta2]
                    case ds of _ {
                      [] -> eta2;
                      : y ys ->
                          let {
                            sat_s1Hu :: [b]
                            [LclId] =
                                \u [] a6 ys eta2;
                          } in  eta1 sat_s1Hu;
                    }; } in
          let {
            sat_s1Ht :: [a]
            [LclId] =
                \u [] eta GHC.Types.[];
          } in  a6 sat_s1Ht;,
  [(Data.DList.$fMonadDList_$c>>, [])]),
 (Data.DList.$fMonadDList [InlPrag=[ALWAYS] CONLIKE]
    :: GHC.Base.Monad Data.DList.DList
  [GblId[DFunId], Caf=NoCafRefs, Str=DmdType m, Unf=OtherCon []] =
      NO_CCS GHC.Base.D:Monad! [Data.DList.$fMonadDList_$c>>=
                                Data.DList.$fMonadDList_$c>>
                                Data.DList.$fApplicativeDList_$creturn
                                Data.DList.$fMonadDList_$cfail];,
  [(Data.DList.$fMonadDList, [])]),
 (Data.DList.$fApplicativeDList_$cpure
    :: forall a. a -> Data.DList.DList a
  [GblId, Arity=2, Caf=NoCafRefs, Str=DmdType LL, Unf=OtherCon []] =
      \r [eta_B2 eta_B1]
          Data.DList.$fApplicativeDList_$creturn eta_B2 eta_B1;,
  [(Data.DList.$fApplicativeDList_$cpure, [])]),
 (Data.DList.$fApplicativeDList_$c<*>
    :: forall a b.
       Data.DList.DList (a -> b)
       -> Data.DList.DList a -> Data.DList.DList b
  [GblId,
   Arity=2,
   Caf=NoCafRefs,
   Str=DmdType C(S)L,
   Unf=OtherCon []] =
      \r [w w1]
          let {
            lvl3 :: [a]
            [LclId] =
                \u [] w1 GHC.Types.[]; } in
          let {
            go [Occ=LoopBreaker] :: [a -> b] -> Data.DList.DList b
            [LclId, Arity=1, Str=DmdType S, Unf=OtherCon []] =
                sat-only \r [ds]
                    case ds of _ {
                      [] -> GHC.Base.id;
                      : y ys ->
                          let {
                            a6 [Dmd=Just L] :: Data.DList.DList b
                            [LclId, Str=DmdType] =
                                \u [] go ys; } in
                          let {
                            a7 [Dmd=Just L] :: Data.DList.DList b
                            [LclId, Str=DmdType] =
                                \u []
                                    let {
                                      go1 [Occ=LoopBreaker] :: [a] -> Data.DList.DList b
                                      [LclId, Arity=1, Str=DmdType S, Unf=OtherCon []] =
                                          sat-only \r [ds1]
                                              case ds1 of _ {
                                                [] -> GHC.Base.id;
                                                : y1 ys1 ->
                                                    let {
                                                      a8 [Dmd=Just L] :: Data.DList.DList b
                                                      [LclId, Str=DmdType] =
                                                          \u [] go1 ys1; } in
                                                    let {
                                                      a9 [Dmd=Just L] :: b
                                                      [LclId, Str=DmdType] =
                                                          \u [] y y1; } in
                                                    let {
                                                      sat_s1Hy :: [b] -> [b]
                                                      [LclId] =
                                                          \r [x]
                                                              let {
                                                                sat_s1Ba :: [b]
                                                                [LclId] =
                                                                    \u [] a8 x;
                                                              } in  : [a9 sat_s1Ba];
                                                    } in  sat_s1Hy;
                                              };
                                    } in  go1 lvl3; } in
                          let {
                            sat_s1Hz :: [b] -> [b]
                            [LclId] =
                                \r [x]
                                    let {
                                      sat_s1Bg :: [b]
                                      [LclId] =
                                          \u [] a6 x;
                                    } in  a7 sat_s1Bg;
                          } in  sat_s1Hz;
                    };
          } in 
            case w GHC.Types.[] of sat_s1Hx { __DEFAULT -> go sat_s1Hx; };,
  [(Data.DList.$fApplicativeDList_$c<*>, [])]),
 (Data.DList.$fApplicativeDList1 [Occ=LoopBreaker]
    :: forall a b. [a] -> [b -> a] -> [b -> a]
  [GblId, Arity=2, Caf=NoCafRefs, Str=DmdType SL, Unf=OtherCon []] =
      \r [ds eta]
          case ds of _ {
            [] -> eta;
            : y ys ->
                let {
                  sat_s1HD :: [b -> a]
                  [LclId] =
                      \u [] Data.DList.$fApplicativeDList1 ys eta; } in
                let {
                  sat_s1HE :: b -> a
                  [LclId] =
                      \r [ds1] y;
                } in  : [sat_s1HE sat_s1HD];
          };,
  [(Data.DList.$fApplicativeDList1, [])]),
 (Data.DList.$fApplicativeDList_$c<*
    :: forall a b.
       Data.DList.DList a -> Data.DList.DList b -> Data.DList.DList a
  [GblId,
   Arity=2,
   Caf=NoCafRefs,
   Str=DmdType C(S)L,
   Unf=OtherCon []] =
      \r [eta1 eta2]
          let {
            lvl3 :: [b]
            [LclId] =
                \u [] eta2 GHC.Types.[]; } in
          let {
            go [Occ=LoopBreaker] :: [b -> a] -> Data.DList.DList a
            [LclId, Arity=1, Str=DmdType S, Unf=OtherCon []] =
                sat-only \r [ds]
                    case ds of _ {
                      [] -> GHC.Base.id;
                      : y ys ->
                          let {
                            a6 [Dmd=Just L] :: Data.DList.DList a
                            [LclId, Str=DmdType] =
                                \u [] go ys; } in
                          let {
                            a7 [Dmd=Just L] :: Data.DList.DList a
                            [LclId, Str=DmdType] =
                                \u []
                                    let {
                                      go1 [Occ=LoopBreaker] :: [b] -> Data.DList.DList a
                                      [LclId, Arity=1, Str=DmdType S, Unf=OtherCon []] =
                                          sat-only \r [ds1]
                                              case ds1 of _ {
                                                [] -> GHC.Base.id;
                                                : y1 ys1 ->
                                                    let {
                                                      a8 [Dmd=Just L] :: Data.DList.DList a
                                                      [LclId, Str=DmdType] =
                                                          \u [] go1 ys1; } in
                                                    let {
                                                      a9 [Dmd=Just L] :: a
                                                      [LclId, Str=DmdType] =
                                                          \u [] y y1; } in
                                                    let {
                                                      sat_s1HH :: [a] -> [a]
                                                      [LclId] =
                                                          \r [x]
                                                              let {
                                                                sat_s1C4 :: [a]
                                                                [LclId] =
                                                                    \u [] a8 x;
                                                              } in  : [a9 sat_s1C4];
                                                    } in  sat_s1HH;
                                              };
                                    } in  go1 lvl3; } in
                          let {
                            sat_s1HI :: [a] -> [a]
                            [LclId] =
                                \r [x]
                                    let {
                                      sat_s1Ca :: [a]
                                      [LclId] =
                                          \u [] a6 x;
                                    } in  a7 sat_s1Ca;
                          } in  sat_s1HI;
                    };
          } in 
            case eta1 GHC.Types.[] of sat_s1HF {
              __DEFAULT ->
                  case
                      Data.DList.$fApplicativeDList1 sat_s1HF GHC.Types.[]
                  of
                  sat_s1HG
                  { __DEFAULT -> go sat_s1HG;
                  };
            };,
  [(Data.DList.$fApplicativeDList_$c<*, [])]),
 (lvl2 :: forall b. b -> b
  [GblId, Arity=1, Caf=NoCafRefs, Unf=OtherCon []] =
      \r [eta] eta;,
  [(lvl2, [])]),
 (Data.DList.$fApplicativeDList2 [Occ=LoopBreaker]
    :: forall a b. [a] -> [b -> b] -> [b -> b]
  [GblId, Arity=2, Caf=NoCafRefs, Str=DmdType SL, Unf=OtherCon []] =
      \r [ds eta]
          case ds of _ {
            [] -> eta;
            : y ys ->
                let {
                  sat_s1HM :: [b -> b]
                  [LclId] =
                      \u [] Data.DList.$fApplicativeDList2 ys eta;
                } in  : [lvl2 sat_s1HM];
          };,
  [(Data.DList.$fApplicativeDList2, [])]),
 (Data.DList.$fApplicativeDList_$c*>
    :: forall a b.
       Data.DList.DList a -> Data.DList.DList b -> Data.DList.DList b
  [GblId,
   Arity=2,
   Caf=NoCafRefs,
   Str=DmdType C(S)L,
   Unf=OtherCon []] =
      \r [eta1 eta2]
          let {
            lvl3 :: [b]
            [LclId] =
                \u [] eta2 GHC.Types.[]; } in
          let {
            go [Occ=LoopBreaker] :: [b -> b] -> Data.DList.DList b
            [LclId, Arity=1, Str=DmdType S, Unf=OtherCon []] =
                sat-only \r [ds]
                    case ds of _ {
                      [] -> GHC.Base.id;
                      : y ys ->
                          let {
                            a6 [Dmd=Just L] :: Data.DList.DList b
                            [LclId, Str=DmdType] =
                                \u [] go ys; } in
                          let {
                            a7 [Dmd=Just L] :: Data.DList.DList b
                            [LclId, Str=DmdType] =
                                \u []
                                    let {
                                      go1 [Occ=LoopBreaker] :: [b] -> Data.DList.DList b
                                      [LclId, Arity=1, Str=DmdType S, Unf=OtherCon []] =
                                          sat-only \r [ds1]
                                              case ds1 of _ {
                                                [] -> GHC.Base.id;
                                                : y1 ys1 ->
                                                    let {
                                                      a8 [Dmd=Just L] :: Data.DList.DList b
                                                      [LclId, Str=DmdType] =
                                                          \u [] go1 ys1; } in
                                                    let {
                                                      a9 [Dmd=Just L] :: b
                                                      [LclId, Str=DmdType] =
                                                          \u [] y y1; } in
                                                    let {
                                                      sat_s1HQ :: [b] -> [b]
                                                      [LclId] =
                                                          \r [x]
                                                              let {
                                                                sat_s1CX :: [b]
                                                                [LclId] =
                                                                    \u [] a8 x;
                                                              } in  : [a9 sat_s1CX];
                                                    } in  sat_s1HQ;
                                              };
                                    } in  go1 lvl3; } in
                          let {
                            sat_s1HR :: [b] -> [b]
                            [LclId] =
                                \r [x]
                                    let {
                                      sat_s1D3 :: [b]
                                      [LclId] =
                                          \u [] a6 x;
                                    } in  a7 sat_s1D3;
                          } in  sat_s1HR;
                    };
          } in 
            case eta1 GHC.Types.[] of sat_s1HO {
              __DEFAULT ->
                  case
                      Data.DList.$fApplicativeDList2 sat_s1HO GHC.Types.[]
                  of
                  sat_s1HP
                  { __DEFAULT -> go sat_s1HP;
                  };
            };,
  [(Data.DList.$fApplicativeDList_$c*>, [])]),
 (Data.DList.$fApplicativeDList [InlPrag=[ALWAYS] CONLIKE]
    :: Control.Applicative.Applicative Data.DList.DList
  [GblId[DFunId], Caf=NoCafRefs, Str=DmdType m, Unf=OtherCon []] =
      NO_CCS Control.Applicative.D:Applicative! [Data.DList.$fFunctorDList
                                                 Data.DList.$fApplicativeDList_$creturn
                                                 Data.DList.$fApplicativeDList_$c<*>
                                                 Data.DList.$fApplicativeDList_$c*>
                                                 Data.DList.$fApplicativeDList_$c<*];,
  [(Data.DList.$fApplicativeDList, [])]),
 (Data.DList.$fAlternativeDList1 [Occ=LoopBreaker]
    :: forall a. [a] -> [[a] -> [a]] -> [[a] -> [a]]
  [GblId, Arity=2, Caf=NoCafRefs, Str=DmdType SL, Unf=OtherCon []] =
      \r [ds eta]
          case ds of _ {
            [] -> eta;
            : y ys ->
                let {
                  sat_s1HV :: [[a] -> [a]]
                  [LclId] =
                      \u [] Data.DList.$fAlternativeDList1 ys eta; } in
                let {
                  sat_s1HW :: [a] -> [a]
                  [LclId] =
                      \r [eta_B1] : [y eta_B1];
                } in  : [sat_s1HW sat_s1HV];
          };,
  [(Data.DList.$fAlternativeDList1, [])]),
 (Data.DList.$fAlternativeDList_$cmany
    :: forall a. Data.DList.DList a -> Data.DList.DList [a]
  [GblId, Arity=1, Caf=NoCafRefs, Str=DmdType L, Unf=OtherCon []] =
      \r [v]
          let {
            lvl3 :: [[a]]
            [LclId] =
                \u [] a7 GHC.Types.[];
            a6 :: Data.DList.DList [a]
            [LclId, Str=DmdType] =
                \u []
                    let {
                      go [Occ=LoopBreaker] :: [[a] -> [a]] -> Data.DList.DList [a]
                      [LclId, Arity=1, Str=DmdType S, Unf=OtherCon []] =
                          sat-only \r [ds]
                              case ds of _ {
                                [] -> GHC.Base.id;
                                : y ys ->
                                    let {
                                      a8 [Dmd=Just L] :: Data.DList.DList [a]
                                      [LclId, Str=DmdType] =
                                          \u [] go ys; } in
                                    let {
                                      a9 [Dmd=Just L] :: Data.DList.DList [a]
                                      [LclId, Str=DmdType] =
                                          \u []
                                              let {
                                                go1 [Occ=LoopBreaker]
                                                  :: [[a]] -> Data.DList.DList [a]
                                                [LclId, Arity=1, Str=DmdType S, Unf=OtherCon []] =
                                                    sat-only \r [ds1]
                                                        case ds1 of _ {
                                                          [] -> GHC.Base.id;
                                                          : y1 ys1 ->
                                                              let {
                                                                a10 [Dmd=Just L]
                                                                  :: Data.DList.DList [a]
                                                                [LclId, Str=DmdType] =
                                                                    \u [] go1 ys1; } in
                                                              let {
                                                                a11 [Dmd=Just L] :: [a]
                                                                [LclId, Str=DmdType] =
                                                                    \u [] y y1; } in
                                                              let {
                                                                sat_s1HZ :: [[a]] -> [[a]]
                                                                [LclId] =
                                                                    \r [x]
                                                                        let {
                                                                          sat_s1DR :: [[a]]
                                                                          [LclId] =
                                                                              \u [] a10 x;
                                                                        } in  : [a11 sat_s1DR];
                                                              } in  sat_s1HZ;
                                                        };
                                              } in  go1 lvl3; } in
                                    let {
                                      sat_s1I0 :: [[a]] -> [[a]]
                                      [LclId] =
                                          \r [x]
                                              let {
                                                sat_s1DX :: [[a]]
                                                [LclId] =
                                                    \u [] a8 x;
                                              } in  a9 sat_s1DX;
                                    } in  sat_s1I0;
                              };
                    } in 
                      case v GHC.Types.[] of sat_s1HX {
                        __DEFAULT ->
                            case
                                Data.DList.$fAlternativeDList1 sat_s1HX GHC.Types.[]
                            of
                            sat_s1HY
                            { __DEFAULT -> go sat_s1HY;
                            };
                      };
            a7 [Occ=LoopBreaker] :: [[a]] -> [[a]]
            [LclId, Arity=1, Str=DmdType L, Unf=OtherCon []] =
                \r [x]
                    let {
                      sat_s1I1 :: [[a]]
                      [LclId] =
                          NO_CCS :! [GHC.Types.[] x];
                    } in  a6 sat_s1I1;
          } in  a7;,
  [(Data.DList.$fAlternativeDList_$cmany, [])]),
 (Data.DList.$fAlternativeDList3 :: forall a. [[a]]
  [GblId, Caf=NoCafRefs, Unf=OtherCon []] =
      NO_CCS :! [GHC.Types.[] GHC.Types.[]];,
  [(Data.DList.$fAlternativeDList3, [])]),
 (Data.DList.$fAlternativeDList2 [Occ=LoopBreaker]
    :: forall a. [a] -> [[a] -> [a]] -> [[a] -> [a]]
  [GblId, Arity=2, Caf=NoCafRefs, Str=DmdType SL, Unf=OtherCon []] =
      \r [ds eta]
          case ds of _ {
            [] -> eta;
            : y ys ->
                let {
                  sat_s1I5 :: [[a] -> [a]]
                  [LclId] =
                      \u [] Data.DList.$fAlternativeDList2 ys eta; } in
                let {
                  sat_s1I6 :: [a] -> [a]
                  [LclId] =
                      \r [eta_B1] : [y eta_B1];
                } in  : [sat_s1I6 sat_s1I5];
          };,
  [(Data.DList.$fAlternativeDList2, [])]),
 (Data.DList.$fAlternativeDList_$csome
    :: forall a. Data.DList.DList a -> Data.DList.DList [a]
  [GblId,
   Arity=1,
   Caf=NoCafRefs,
   Str=DmdType C(S),
   Unf=OtherCon []] =
      \r [v]
          let {
            lvl3 :: [[a]]
            [LclId] =
                \u [] some_v Data.DList.$fAlternativeDList3;
            some_v [Occ=LoopBreaker] :: Data.DList.DList [a]
            [LclId, Str=DmdType] =
                \u []
                    let {
                      go [Occ=LoopBreaker] :: [[a] -> [a]] -> Data.DList.DList [a]
                      [LclId, Arity=1, Str=DmdType S, Unf=OtherCon []] =
                          sat-only \r [ds]
                              case ds of _ {
                                [] -> GHC.Base.id;
                                : y ys ->
                                    let {
                                      a6 [Dmd=Just L] :: Data.DList.DList [a]
                                      [LclId, Str=DmdType] =
                                          \u [] go ys; } in
                                    let {
                                      a7 [Dmd=Just L] :: Data.DList.DList [a]
                                      [LclId, Str=DmdType] =
                                          \u []
                                              let {
                                                go1 [Occ=LoopBreaker]
                                                  :: [[a]] -> Data.DList.DList [a]
                                                [LclId, Arity=1, Str=DmdType S, Unf=OtherCon []] =
                                                    sat-only \r [ds1]
                                                        case ds1 of _ {
                                                          [] -> GHC.Base.id;
                                                          : y1 ys1 ->
                                                              let {
                                                                a8 [Dmd=Just L]
                                                                  :: Data.DList.DList [a]
                                                                [LclId, Str=DmdType] =
                                                                    \u [] go1 ys1; } in
                                                              let {
                                                                a9 [Dmd=Just L] :: [a]
                                                                [LclId, Str=DmdType] =
                                                                    \u [] y y1; } in
                                                              let {
                                                                sat_s1I9 :: [[a]] -> [[a]]
                                                                [LclId] =
                                                                    \r [x]
                                                                        let {
                                                                          sat_s1EO :: [[a]]
                                                                          [LclId] =
                                                                              \u [] a8 x;
                                                                        } in  : [a9 sat_s1EO];
                                                              } in  sat_s1I9;
                                                        };
                                              } in  go1 lvl3; } in
                                    let {
                                      sat_s1Ia :: [[a]] -> [[a]]
                                      [LclId] =
                                          \r [x]
                                              let {
                                                sat_s1EU :: [[a]]
                                                [LclId] =
                                                    \u [] a6 x;
                                              } in  a7 sat_s1EU;
                                    } in  sat_s1Ia;
                              };
                    } in 
                      case v GHC.Types.[] of sat_s1I7 {
                        __DEFAULT ->
                            case
                                Data.DList.$fAlternativeDList2 sat_s1I7 GHC.Types.[]
                            of
                            sat_s1I8
                            { __DEFAULT -> go sat_s1I8;
                            };
                      };
          } in  some_v;,
  [(Data.DList.$fAlternativeDList_$csome, [])]),
 (Data.DList.$fAlternativeDList [InlPrag=[ALWAYS] CONLIKE]
    :: Control.Applicative.Alternative Data.DList.DList
  [GblId[DFunId], Str=DmdType m, Unf=OtherCon []] =
      NO_CCS Control.Applicative.D:Alternative! [Data.DList.$fApplicativeDList
                                                 GHC.Base.id
                                                 Data.DList.append
                                                 Data.DList.$fAlternativeDList_$csome
                                                 Data.DList.$fAlternativeDList_$cmany];,
  [(Data.DList.$fAlternativeDList, [])]),
 (Data.DList.$fMonadPlusDList [InlPrag=[ALWAYS] CONLIKE]
    :: Control.Monad.MonadPlus Data.DList.DList
  [GblId[DFunId], Str=DmdType m, Unf=OtherCon []] =
      NO_CCS Control.Monad.D:MonadPlus! [Data.DList.$fMonadDList
                                         GHC.Base.id
                                         Data.DList.append];,
  [(Data.DList.$fMonadPlusDList, [])]),
 (Data.DList.$fFoldableDList_$cfoldl1 [InlPrag=INLINE (sat-args=1)]
    :: forall a. (a -> a -> a) -> Data.DList.DList a -> a
  [GblId, Arity=2, Str=DmdType LC(S), Unf=OtherCon []] =
      \r srt:(0,*bitmap*) [eta eta1]
          case eta1 GHC.Types.[] of _ {
            [] -> Data.List.foldl2;
            : x xs -> GHC.List.foldl eta x xs;
          };,
  [(Data.DList.$fFoldableDList_$cfoldl1, [Data.List.foldl2])]),
 (Data.DList.$fFoldableDList_$cfoldr1 [InlPrag=INLINE (sat-args=1)]
    :: forall a. (a -> a -> a) -> Data.DList.DList a -> a
  [GblId, Arity=2, Str=DmdType LC(S), Unf=OtherCon []] =
      \r srt:(0,*bitmap*) [eta eta1]
          case eta1 GHC.Types.[] of sat_s1Ie {
            __DEFAULT -> GHC.List.foldr1 eta sat_s1Ie;
          };,
  [(Data.DList.$fFoldableDList_$cfoldr1, [GHC.List.foldr1])]),
 (Data.DList.$fFoldableDList_$cfoldl' [InlPrag=INLINE (sat-args=2)]
    :: forall a b. (a -> b -> a) -> a -> Data.DList.DList b -> a
  [GblId,
   Arity=3,
   Caf=NoCafRefs,
   Str=DmdType LLC(S),
   Unf=OtherCon []] =
      \r [eta eta1 eta2]
          case eta2 GHC.Types.[] of sat_s1If {
            __DEFAULT -> Data.List.foldl' eta eta1 sat_s1If;
          };,
  [(Data.DList.$fFoldableDList_$cfoldl', [])]),
 (Data.DList.$fFoldableDList_$cfoldl [InlPrag=INLINE (sat-args=2)]
    :: forall a b. (a -> b -> a) -> a -> Data.DList.DList b -> a
  [GblId,
   Arity=3,
   Caf=NoCafRefs,
   Str=DmdType LLC(S),
   Unf=OtherCon []] =
      \r [eta eta1 eta2]
          case eta2 GHC.Types.[] of sat_s1Ig {
            __DEFAULT -> GHC.List.foldl eta eta1 sat_s1Ig;
          };,
  [(Data.DList.$fFoldableDList_$cfoldl, [])]),
 (Data.DList.$fFoldableDList_$cfoldr' [InlPrag=INLINE (sat-args=2)]
    :: forall a b. (a -> b -> b) -> b -> Data.DList.DList a -> b
  [GblId,
   Arity=3,
   Caf=NoCafRefs,
   Str=DmdType LLC(S),
   Unf=OtherCon []] =
      \r [eta eta1 eta2]
          case eta2 GHC.Types.[] of sat_s1Ih {
            __DEFAULT -> Data.Foldable.$fFoldable[]_$cfoldr' eta eta1 sat_s1Ih;
          };,
  [(Data.DList.$fFoldableDList_$cfoldr', [])]),
 (Data.DList.$fFoldableDList_$cfoldr [InlPrag=INLINE (sat-args=2)]
    :: forall a b. (a -> b -> b) -> b -> Data.DList.DList a -> b
  [GblId,
   Arity=3,
   Caf=NoCafRefs,
   Str=DmdType LLC(S),
   Unf=OtherCon []] =
      \r [eta_B3 eta_B2 eta_B1] Data.DList.foldr eta_B3 eta_B2 eta_B1;,
  [(Data.DList.$fFoldableDList_$cfoldr, [])]),
 (Data.DList.$fFoldableDList_$cfoldMap [InlPrag=INLINE (sat-args=1)]
    :: forall a m.
       Data.Monoid.Monoid m =>
       (a -> m) -> Data.DList.DList a -> m
  [GblId,
   Arity=3,
   Caf=NoCafRefs,
   Str=DmdType U(LLA)LC(S),
   Unf=OtherCon []] =
      \r [eta f eta1]
          case eta of _ {
            Data.Monoid.D:Monoid ww ww1 ww2 ->
                case eta1 GHC.Types.[] of sat_s1Ii {
                  __DEFAULT -> Data.Foldable.$w$cfoldMap2 ww ww1 f sat_s1Ii;
                };
          };,
  [(Data.DList.$fFoldableDList_$cfoldMap, [])]),
 (Data.DList.$fFoldableDList_$cfold [InlPrag=INLINE (sat-args=0)]
    :: forall m. Data.Monoid.Monoid m => Data.DList.DList m -> m
  [GblId,
   Arity=2,
   Caf=NoCafRefs,
   Str=DmdType U(AAS)L,
   Unf=OtherCon []] =
      \r [$dMonoid eta]
          let {
            sat_s1Il :: [m]
            [LclId] =
                \u [] eta GHC.Types.[];
          } in  Data.Monoid.mconcat $dMonoid sat_s1Il;,
  [(Data.DList.$fFoldableDList_$cfold, [])]),
 (Data.DList.$fFoldableDList [InlPrag=[ALWAYS] CONLIKE]
    :: Data.Foldable.Foldable Data.DList.DList
  [GblId[DFunId], Str=DmdType m, Unf=OtherCon []] =
      NO_CCS Data.Foldable.D:Foldable! [Data.DList.$fFoldableDList_$cfold
                                        Data.DList.$fFoldableDList_$cfoldMap
                                        Data.DList.$fFoldableDList_$cfoldr
                                        Data.DList.$fFoldableDList_$cfoldr'
                                        Data.DList.$fFoldableDList_$cfoldl
                                        Data.DList.$fFoldableDList_$cfoldl'
                                        Data.DList.$fFoldableDList_$cfoldr1
                                        Data.DList.$fFoldableDList_$cfoldl1];,
  [(Data.DList.$fFoldableDList, [])])]