[(Data.Generics.Schemes.everything [Occ=LoopBreaker]
    :: forall r.
       (r -> r -> r)
       -> Data.Generics.Aliases.GenericQ r
       -> Data.Generics.Aliases.GenericQ r
  [GblId,
   Arity=4,
   Caf=NoCafRefs,
   Str=DmdType LLS(AAAAAAAAAASAAAA)L,
   Unf=OtherCon []] =
      \r [dk dk1 $dData x]
          let {
            sat_s5UI :: forall d. Data.Data.Data d => d -> r
            [LclId] =
                \r [$dData1 eta_B1]
                    Data.Generics.Schemes.everything dk dk1 $dData1 eta_B1;
          } in 
            case Data.Data.gmapQ $dData sat_s5UI x of sat_s5UJ {
              __DEFAULT ->
                  let {
                    sat_s5UK :: r
                    [LclId] =
                        \u [] dk1 $dData x;
                  } in  GHC.List.foldl dk sat_s5UK sat_s5UJ;
            };,
  [(Data.Generics.Schemes.everything, [])]),
 (Data.Generics.Schemes.everythingBut [Occ=LoopBreaker]
    :: forall r.
       (r -> r -> r)
       -> Data.Generics.Aliases.GenericQ (r, GHC.Types.Bool)
       -> Data.Generics.Aliases.GenericQ r
  [GblId,
   Arity=4,
   Caf=NoCafRefs,
   Str=DmdType LC(C(U(LS)))LL,
   Unf=OtherCon []] =
      \r [dk dk1 $dData x]
          case dk1 $dData x of _ {
            (,) v stop ->
                case stop of _ {
                  GHC.Types.False ->
                      let {
                        sat_s5US :: forall d. Data.Data.Data d => d -> r
                        [LclId] =
                            \r [$dData1 eta_B1]
                                Data.Generics.Schemes.everythingBut dk dk1 $dData1 eta_B1;
                      } in 
                        case Data.Data.gmapQ $dData sat_s5US x of sat_s5UT {
                          __DEFAULT -> GHC.List.foldl dk v sat_s5UT;
                        };
                  GHC.Types.True -> v;
                };
          };,
  [(Data.Generics.Schemes.everythingBut, [])]),
 (Data.Generics.Schemes.everythingWithContext [Occ=LoopBreaker]
    :: forall s r.
       s
       -> (r -> r -> r)
       -> Data.Generics.Aliases.GenericQ (s -> (r, s))
       -> Data.Generics.Aliases.GenericQ r
  [GblId,
   Arity=5,
   Caf=NoCafRefs,
   Str=DmdType LLLS(AAAAAAAAAASAAAA)L,
   Unf=OtherCon []] =
      \r [dk dk1 dk2 $dData x]
          let {
            ds [Dmd=Just D(SS)] :: (r, s)
            [LclId, Str=DmdType] =
                \u [] dk2 $dData x dk; } in
          let {
            s' [Dmd=Just L] :: s
            [LclId, Str=DmdType] =
                \u [] case ds of _ { (,) r s'1 -> s'1; }; } in
          let {
            sat_s5Va :: forall d. Data.Data.Data d => d -> r
            [LclId] =
                \r [$dData1 eta_B1]
                    Data.Generics.Schemes.everythingWithContext
                        s' dk1 dk2 $dData1 eta_B1;
          } in 
            case Data.Data.gmapQ $dData sat_s5Va x of sat_s5Vb {
              __DEFAULT ->
                  let {
                    sat_s5Vc :: r
                    [LclId] =
                        \u [] case ds of _ { (,) r s'1 -> r; };
                  } in  GHC.List.foldl dk1 sat_s5Vc sat_s5Vb;
            };,
  [(Data.Generics.Schemes.everythingWithContext, [])]),
 (Data.Generics.Schemes.everywhere [Occ=LoopBreaker]
    :: (forall a. Data.Data.Data a => a -> a)
       -> forall a. Data.Data.Data a => a -> a
  [GblId, Arity=2, Caf=NoCafRefs, Str=DmdType LL, Unf=OtherCon []] =
      \r [dk $dData]
          let {
            g [Dmd=Just L] :: a -> a
            [LclId, Str=DmdType] =
                \u []
                    let {
                      sat_s5PY :: forall b. Data.Data.Data b => b -> b
                      [LclId] =
                          \r [$dData1] Data.Generics.Schemes.everywhere dk $dData1;
                    } in  Data.Data.gmapT $dData sat_s5PY; } in
          let {
            f [Dmd=Just L] :: a -> a
            [LclId, Str=DmdType] =
                \u [] dk $dData; } in
          let {
            sat_s5Vx :: a -> a
            [LclId] =
                \r [x]
                    let {
                      sat_s5Q5 :: a
                      [LclId] =
                          \u [] g x;
                    } in  f sat_s5Q5;
          } in  sat_s5Vx;,
  [(Data.Generics.Schemes.everywhere, [])]),
 (Data.Generics.Schemes.everywhere' [Occ=LoopBreaker]
    :: (forall a. Data.Data.Data a => a -> a)
       -> forall a. Data.Data.Data a => a -> a
  [GblId, Arity=2, Caf=NoCafRefs, Str=DmdType LL, Unf=OtherCon []] =
      \r [dk $dData]
          let {
            g [Dmd=Just L] :: a -> a
            [LclId, Str=DmdType] =
                \u [] dk $dData; } in
          let {
            f [Dmd=Just L] :: a -> a
            [LclId, Str=DmdType] =
                \u []
                    let {
                      sat_s5Qh :: forall b. Data.Data.Data b => b -> b
                      [LclId] =
                          \r [$dData1] Data.Generics.Schemes.everywhere' dk $dData1;
                    } in  Data.Data.gmapT $dData sat_s5Qh; } in
          let {
            sat_s5VB :: a -> a
            [LclId] =
                \r [x]
                    let {
                      sat_s5Qm :: a
                      [LclId] =
                          \u [] g x;
                    } in  f sat_s5Qm;
          } in  sat_s5VB;,
  [(Data.Generics.Schemes.everywhere', [])]),
 (Data.Generics.Schemes.everywhereBut [Occ=LoopBreaker]
    :: Data.Generics.Aliases.GenericQ GHC.Types.Bool
       -> Data.Generics.Aliases.GenericT -> Data.Generics.Aliases.GenericT
  [GblId,
   Arity=4,
   Caf=NoCafRefs,
   Str=DmdType C(C(S))LLL,
   Unf=OtherCon []] =
      \r [dk dk1 $dData x]
          case dk $dData x of _ {
            GHC.Types.False ->
                let {
                  sat_s5VF :: a
                  [LclId] =
                      \u []
                          let {
                            sat_s5QA :: forall b. Data.Data.Data b => b -> b
                            [LclId] =
                                \r [$dData1 eta_B1]
                                    Data.Generics.Schemes.everywhereBut dk dk1 $dData1 eta_B1;
                          } in  Data.Data.gmapT $dData sat_s5QA x;
                } in  dk1 $dData sat_s5VF;
            GHC.Types.True -> x;
          };,
  [(Data.Generics.Schemes.everywhereBut, [])]),
 (Data.Generics.Schemes.everywhereM [Occ=LoopBreaker]
    :: forall (m :: * -> *).
       GHC.Base.Monad m =>
       Data.Generics.Aliases.GenericM m
       -> Data.Generics.Aliases.GenericM m
  [GblId,
   Arity=4,
   Caf=NoCafRefs,
   Str=DmdType S(SAAA)LLL,
   Unf=OtherCon []] =
      \r [$dMonad dk $dData x]
          let {
            sat_s5VO :: a -> m a
            [LclId] =
                \r [x'] dk $dData x'; } in
          let {
            sat_s5VP :: m a
            [LclId] =
                \u []
                    let {
                      sat_s5QN :: forall d. Data.Data.Data d => d -> m d
                      [LclId] =
                          \r [$dData1 eta_B1]
                              Data.Generics.Schemes.everywhereM $dMonad dk $dData1 eta_B1;
                    } in  Data.Data.gmapM $dData $dMonad sat_s5QN x;
          } in  GHC.Base.>>= $dMonad sat_s5VP sat_s5VO;,
  [(Data.Generics.Schemes.everywhereM, [])]),
 (Data.Generics.Schemes.gcount2 :: GHC.Types.Int
  [GblId, Caf=NoCafRefs, Str=DmdType m, Unf=OtherCon []] =
      NO_CCS GHC.Types.I#! [0];,
  [(Data.Generics.Schemes.gcount2, [])]),
 (Data.Generics.Schemes.gcount1 :: GHC.Types.Int
  [GblId, Caf=NoCafRefs, Str=DmdType m, Unf=OtherCon []] =
      NO_CCS GHC.Types.I#! [1];,
  [(Data.Generics.Schemes.gcount1, [])]),
 (Data.Generics.Schemes.gcount
    :: Data.Generics.Aliases.GenericQ GHC.Types.Bool
       -> Data.Generics.Aliases.GenericQ GHC.Types.Int
  [GblId,
   Arity=3,
   Caf=NoCafRefs,
   Str=DmdType LS(AAAAAAAAAASAAAA)L,
   Unf=OtherCon []] =
      \r [dk $dData eta]
          let {
            sat_s5VU :: Data.Generics.Aliases.GenericQ GHC.Types.Int
            [LclId] =
                \r [$dData1 x]
                    case dk $dData1 x of _ {
                      GHC.Types.False -> Data.Generics.Schemes.gcount2;
                      GHC.Types.True -> Data.Generics.Schemes.gcount1;
                    };
          } in 
            Data.Generics.Schemes.everything
                GHC.Num.$fNumInt_$c+ sat_s5VU $dData eta;,
  [(Data.Generics.Schemes.gcount, [])]),
 ($wgo :: [GHC.Types.Int] -> GHC.Prim.Int#
  [GblId, Arity=1, Caf=NoCafRefs, Str=DmdType S, Unf=OtherCon []] =
      sat-only \r [w]
          case w of _ {
            [] -> 0;
            : y ys ->
                case y of _ {
                  GHC.Types.I# x1 ->
                      case $wgo ys of ww {
                        __DEFAULT ->
                            case <=# [x1 ww] of _ {
                              GHC.Types.False -> x1;
                              GHC.Types.True -> ww;
                            };
                      };
                };
          };,
  [($wgo, [])]),
 (Data.Generics.Schemes.gdepth [Occ=LoopBreaker]
    :: Data.Generics.Aliases.GenericQ GHC.Types.Int
  [GblId, Arity=1, Caf=NoCafRefs, Str=DmdType L, Unf=OtherCon []] =
      \r [$dData]
          let {
            g [Dmd=Just L] :: a -> [GHC.Types.Int]
            [LclId, Str=DmdType] =
                \u [] Data.Data.gmapQ $dData Data.Generics.Schemes.gdepth; } in
          let {
            sat_s5W8 :: a -> GHC.Types.Int
            [LclId] =
                \r [x]
                    case g x of sat_s5W7 {
                      __DEFAULT ->
                          case $wgo sat_s5W7 of ww {
                            __DEFAULT ->
                                case +# [1 ww] of sat_s5W6 {
                                  __DEFAULT -> GHC.Types.I# [sat_s5W6];
                                };
                          };
                    };
          } in  sat_s5W8;,
  [(Data.Generics.Schemes.gdepth, [])]),
 (Data.Generics.Schemes.gfindtype1 [Occ=LoopBreaker]
    :: forall y. [y] -> [Data.Maybe.Maybe y] -> [y]
  [GblId, Arity=2, Caf=NoCafRefs, Str=DmdType LS, Unf=OtherCon []] =
      \r [z ds]
          case ds of _ {
            [] -> z;
            : x xs ->
                let {
                  sat_s5Wa :: [y]
                  [LclId] =
                      \u []
                          case x of _ {
                            Data.Maybe.Nothing -> z;
                            Data.Maybe.Just x1 -> : [x1 z];
                          };
                } in  Data.Generics.Schemes.gfindtype1 sat_s5Wa xs;
          };,
  [(Data.Generics.Schemes.gfindtype1, [])]),
 (Data.Generics.Schemes.gfindtype
    :: forall x y.
       (Data.Data.Data x, Data.Typeable.Internal.Typeable y) =>
       x -> Data.Maybe.Maybe y
  [GblId, Arity=2, Str=DmdType LL, Unf=OtherCon []] =
      \r srt:(0,*bitmap*) [$dData $dTypeable]
          let {
            g [Dmd=Just L] :: x -> [Data.Maybe.Maybe y]
            [LclId, Str=DmdType] =
                \u srt:(0,*bitmap*) []
                    let {
                      sat_s5RR :: forall d. Data.Data.Data d => d -> Data.Maybe.Maybe y
                      [LclId] =
                          \r srt:(0,*bitmap*) [$dData1]
                              let {
                                $dTypeable1 [Dmd=Just L] :: Data.Typeable.Internal.Typeable d
                                [LclId, Str=DmdType] =
                                    \u [] Data.Data.$p1Data $dData1;
                              } in  Data.Typeable.cast $dTypeable1 $dTypeable;
                    } in  Data.Data.gmapQ $dData sat_s5RR; } in
          let {
            sat_s5Wd :: x -> Data.Maybe.Maybe y
            [LclId] =
                \r [x]
                    case g x of sat_s5Wc {
                      __DEFAULT ->
                          case Data.Generics.Schemes.gfindtype1 GHC.Types.[] sat_s5Wc of _ {
                            [] -> Data.Maybe.Nothing [];
                            : s ds ->
                                case ds of _ {
                                  [] -> Data.Maybe.Just [s];
                                  : ipv ipv1 -> Data.Maybe.Nothing [];
                                };
                          };
                    };
          } in  sat_s5Wd;,
  [(Data.Generics.Schemes.gfindtype, [Data.Typeable.cast])]),
 (Data.Generics.Schemes.glength1
    :: forall d. Data.Data.Data d => d -> ()
  [GblId, Arity=2, Caf=NoCafRefs, Str=DmdType AA, Unf=OtherCon []] =
      \r [$dData eta] () [];,
  [(Data.Generics.Schemes.glength1, [])]),
 (Data.Generics.Schemes.glength
    :: Data.Generics.Aliases.GenericQ GHC.Types.Int
  [GblId, Arity=1, Caf=NoCafRefs, Str=DmdType L, Unf=OtherCon []] =
      \r [$dData]
          let {
            g [Dmd=Just L] :: a -> [()]
            [LclId, Str=DmdType] =
                \u [] Data.Data.gmapQ $dData Data.Generics.Schemes.glength1; } in
          let {
            sat_s5Wj :: a -> GHC.Types.Int
            [LclId] =
                \r [x]
                    case g x of sat_s5Wi {
                      __DEFAULT ->
                          case GHC.List.$wlen sat_s5Wi 0 of ww {
                            __DEFAULT -> GHC.Types.I# [ww];
                          };
                    };
          } in  sat_s5Wj;,
  [(Data.Generics.Schemes.glength, [])]),
 (Data.Generics.Schemes.gnodecount1
    :: forall a. Data.Data.Data a => a -> GHC.Types.Int
  [GblId, Arity=2, Caf=NoCafRefs, Unf=OtherCon []] =
      \r [$dData x] Data.Generics.Schemes.gcount1;,
  [(Data.Generics.Schemes.gnodecount1, [])]),
 (Data.Generics.Schemes.gnodecount
    :: Data.Generics.Aliases.GenericQ GHC.Types.Int
  [GblId,
   Arity=2,
   Caf=NoCafRefs,
   Str=DmdType S(AAAAAAAAAASAAAA)L,
   Unf=OtherCon []] =
      \r [$dData eta]
          Data.Generics.Schemes.everything
              GHC.Num.$fNumInt_$c+ Data.Generics.Schemes.gnodecount1 $dData eta;,
  [(Data.Generics.Schemes.gnodecount, [])]),
 (Data.Generics.Schemes.gsize [InlPrag=INLINE[0]]
    :: forall a. Data.Data.Data a => a -> GHC.Types.Int
  [GblId,
   Arity=2,
   Caf=NoCafRefs,
   Str=DmdType U(AAAAAAAAAASAAAA)Lm,
   Unf=OtherCon []] =
      \r [w w1]
          case w of _ {
            Data.Data.D:Data ww
                             ww1
                             ww2
                             ww3
                             ww4
                             ww5
                             ww6
                             ww7
                             ww8
                             ww9
                             ww10
                             ww11
                             ww12
                             ww13
                             ww14 ->
                case Data.Generics.Schemes.$wgsize ww10 w1 of ww15 {
                  __DEFAULT -> GHC.Types.I# [ww15];
                };
          };
  Data.Generics.Schemes.$wgsize [Occ=LoopBreaker]
    :: forall a.
       (forall u. (forall d. Data.Data.Data d => d -> u) -> a -> [u])
       -> a -> GHC.Prim.Int#
  [GblId, Arity=2, Caf=NoCafRefs, Str=DmdType SL, Unf=OtherCon []] =
      \r [ww w]
          case ww Data.Generics.Schemes.gsize w of sat_s5Wz {
            __DEFAULT ->
                case Data.List.$wsum' sat_s5Wz 0 of ww1 {
                  __DEFAULT -> +# [1 ww1];
                };
          };,
  [(Data.Generics.Schemes.gsize, []),
   (Data.Generics.Schemes.$wgsize, [])]),
 (Data.Generics.Schemes.$wgtypecount
    :: forall a.
       Data.Typeable.Internal.Typeable a =>
       forall a1. Data.Data.Data a1 => a1 -> GHC.Types.Int
  [GblId,
   Arity=3,
   Str=DmdType LS(AAAAAAAAAASAAAA)L,
   Unf=OtherCon []] =
      \r srt:(0,*bitmap*) [w w1 w2]
          let {
            sat_s5WG :: Data.Generics.Aliases.GenericQ GHC.Types.Int
            [LclId] =
                \r srt:(0,*bitmap*) [$dData x]
                    let {
                      r [Occ=LoopBreaker] :: Data.Maybe.Maybe a
                      [LclId, Str=DmdType] =
                          \u srt:(0,*bitmap*) []
                              case Data.Data.$p1Data $dData x of _ {
                                Data.Typeable.Internal.TypeRep rb rb1 _ _ ->
                                    let {
                                      sat_s5WA :: a
                                      [LclId] =
                                          \u srt:(0,*bitmap*) []
                                              case r of _ {
                                                Data.Maybe.Nothing -> Data.Maybe.fromJust1;
                                                Data.Maybe.Just x1 -> x1;
                                              };
                                    } in 
                                      case w sat_s5WA of _ {
                                        Data.Typeable.Internal.TypeRep rb2 rb3 _ _ ->
                                            case eqWord# [rb rb2] of _ {
                                              GHC.Types.False -> Data.Maybe.Nothing [];
                                              GHC.Types.True ->
                                                  case eqWord# [rb1 rb3] of _ {
                                                    GHC.Types.False -> Data.Maybe.Nothing [];
                                                    GHC.Types.True -> Data.Maybe.Just [x];
                                                  };
                                            };
                                      };
                              };
                    } in 
                      case r of _ {
                        Data.Maybe.Nothing -> Data.Generics.Schemes.gcount2;
                        Data.Maybe.Just b -> Data.Generics.Schemes.gcount1;
                      };
          } in 
            Data.Generics.Schemes.everything
                GHC.Num.$fNumInt_$c+ sat_s5WG w1 w2;,
  [(Data.Generics.Schemes.$wgtypecount, [Data.Maybe.fromJust1])]),
 (Data.Generics.Schemes.gtypecount [InlPrag=INLINE[0]]
    :: forall a.
       Data.Typeable.Internal.Typeable a =>
       a -> Data.Generics.Aliases.GenericQ GHC.Types.Int
  [GblId,
   Arity=4,
   Str=DmdType LAS(AAAAAAAAAASAAAA)L,
   Unf=OtherCon []] =
      \r srt:(0,*bitmap*) [w w1 w2 w3]
          Data.Generics.Schemes.$wgtypecount w w2 w3;,
  [(Data.Generics.Schemes.gtypecount, [Data.Maybe.fromJust1])]),
 (Data.Generics.Schemes.listify
    :: forall r.
       Data.Typeable.Internal.Typeable r =>
       (r -> GHC.Types.Bool) -> Data.Generics.Aliases.GenericQ [r]
  [GblId,
   Arity=4,
   Str=DmdType LLS(AAAAAAAAAASAAAA)L,
   Unf=OtherCon []] =
      \r srt:(0,*bitmap*) [$dTypeable dk $dData eta]
          let {
            sat_s5WO :: Data.Generics.Aliases.GenericQ [r]
            [LclId] =
                \r srt:(0,*bitmap*) [$dData1]
                    let {
                      $dTypeable1 [Dmd=Just L] :: Data.Typeable.Internal.Typeable a1
                      [LclId, Str=DmdType] =
                          \u [] Data.Data.$p1Data $dData1; } in
                    let {
                      sat_s5WN :: a1 -> [r]
                      [LclId] =
                          \r srt:(0,*bitmap*) [a]
                              case Data.Typeable.cast $dTypeable1 $dTypeable a of _ {
                                Data.Maybe.Nothing -> [] [];
                                Data.Maybe.Just b ->
                                    case dk b of _ {
                                      GHC.Types.False -> [] [];
                                      GHC.Types.True -> : [b GHC.Types.[]];
                                    };
                              };
                    } in  sat_s5WN;
          } in 
            Data.Generics.Schemes.everything GHC.Base.++ sat_s5WO $dData eta;,
  [(Data.Generics.Schemes.listify, [Data.Typeable.cast])]),
 (Data.Generics.Schemes.something
    :: forall u.
       Data.Generics.Aliases.GenericQ (Data.Maybe.Maybe u)
       -> Data.Generics.Aliases.GenericQ (Data.Maybe.Maybe u)
  [GblId,
   Arity=3,
   Caf=NoCafRefs,
   Str=DmdType LS(AAAAAAAAAASAAAA)L,
   Unf=OtherCon []] =
      \r [dk $dData eta]
          Data.Generics.Schemes.everything
              Data.Generics.Aliases.orElse dk $dData eta;,
  [(Data.Generics.Schemes.something, [])]),
 (Data.Generics.Schemes.somewhere [Occ=LoopBreaker]
    :: forall (m :: * -> *).
       Control.Monad.MonadPlus m =>
       Data.Generics.Aliases.GenericM m
       -> Data.Generics.Aliases.GenericM m
  [GblId,
   Arity=4,
   Caf=NoCafRefs,
   Str=DmdType S(AAS)LLL,
   Unf=OtherCon []] =
      \r [$dMonadPlus dk $dData x]
          let {
            sat_s5WR :: m a
            [LclId] =
                \u []
                    let {
                      sat_s5Ue :: forall d. Data.Data.Data d => d -> m d
                      [LclId] =
                          \r [$dData1 eta_B1]
                              Data.Generics.Schemes.somewhere $dMonadPlus dk $dData1 eta_B1;
                    } in  Data.Data.gmapMp $dData $dMonadPlus sat_s5Ue x; } in
          let {
            sat_s5WS :: m a
            [LclId] =
                \u [] dk $dData x;
          } in  Control.Monad.mplus $dMonadPlus sat_s5WS sat_s5WR;,
  [(Data.Generics.Schemes.somewhere, [])]),
 (Data.Generics.Schemes.synthesize [Occ=LoopBreaker]
    :: forall s t.
       s
       -> (t -> s -> s)
       -> Data.Generics.Aliases.GenericQ (s -> t)
       -> Data.Generics.Aliases.GenericQ t
  [GblId,
   Arity=5,
   Caf=NoCafRefs,
   Str=DmdType LLC(C(C(S)))LL,
   Unf=OtherCon []] =
      \r [dk dk1 dk2 $dData x]
          let {
            sat_s5WV :: s
            [LclId] =
                \u []
                    let {
                      go [Occ=LoopBreaker] :: [t] -> s
                      [LclId, Arity=1, Str=DmdType S, Unf=OtherCon []] =
                          sat-only \r [ds]
                              case ds of _ {
                                [] -> dk;
                                : y ys ->
                                    let {
                                      sat_s5WU :: s
                                      [LclId] =
                                          \u [] go ys;
                                    } in  dk1 y sat_s5WU;
                              }; } in
                    let {
                      sat_s5UE :: forall d. Data.Data.Data d => d -> t
                      [LclId] =
                          \r [$dData1 eta_B1]
                              Data.Generics.Schemes.synthesize dk dk1 dk2 $dData1 eta_B1;
                    } in 
                      case Data.Data.gmapQ $dData sat_s5UE x of sat_s5WT {
                        __DEFAULT -> go sat_s5WT;
                      };
          } in  dk2 $dData x sat_s5WV;,
  [(Data.Generics.Schemes.synthesize, [])])]