[(Data.Generics.Twins.unA1
    :: forall a (c :: * -> *) d.
       Data.Generics.Twins.A a c d -> Data.Generics.Twins.A a c d
  [GblId, Arity=1, Caf=NoCafRefs, Str=DmdType S, Unf=OtherCon []] =
      \r [ds] ds;,
  [(Data.Generics.Twins.unA1, [])]),
 (Data.Generics.Twins.unA
    :: forall a (c :: * -> *) d.
       Data.Generics.Twins.A a c d -> a -> (a, c d)
  [GblId[[RecSel]],
   Arity=1,
   Caf=NoCafRefs,
   Str=DmdType S,
   Unf=OtherCon []] =
      \r [eta_B1] Data.Generics.Twins.unA1 eta_B1;,
  [(Data.Generics.Twins.unA, [])]),
 (Data.Generics.Twins.unID1
    :: forall x. Data.Generics.Twins.ID x -> Data.Generics.Twins.ID x
  [GblId, Arity=1, Caf=NoCafRefs, Str=DmdType S, Unf=OtherCon []] =
      \r [ds] ds;,
  [(Data.Generics.Twins.unID1, [])]),
 (Data.Generics.Twins.unID
    :: forall x. Data.Generics.Twins.ID x -> x
  [GblId[[RecSel]],
   Arity=1,
   Caf=NoCafRefs,
   Str=DmdType S,
   Unf=OtherCon []] =
      \r [eta_B1] Data.Generics.Twins.unID1 eta_B1;,
  [(Data.Generics.Twins.unID, [])]),
 (Data.Generics.Twins.unCONST1
    :: forall c a.
       Data.Generics.Twins.CONST c a -> Data.Generics.Twins.CONST c a
  [GblId, Arity=1, Caf=NoCafRefs, Str=DmdType S, Unf=OtherCon []] =
      \r [ds] ds;,
  [(Data.Generics.Twins.unCONST1, [])]),
 (Data.Generics.Twins.unCONST
    :: forall c a. Data.Generics.Twins.CONST c a -> c
  [GblId[[RecSel]],
   Arity=1,
   Caf=NoCafRefs,
   Str=DmdType S,
   Unf=OtherCon []] =
      \r [eta_B1] Data.Generics.Twins.unCONST1 eta_B1;,
  [(Data.Generics.Twins.unCONST, [])]),
 (Data.Generics.Twins.unQr1
    :: forall r a.
       Data.Generics.Twins.Qr r a -> Data.Generics.Twins.Qr r a
  [GblId, Arity=1, Caf=NoCafRefs, Str=DmdType S, Unf=OtherCon []] =
      \r [ds] ds;,
  [(Data.Generics.Twins.unQr1, [])]),
 (Data.Generics.Twins.unQr
    :: forall r a. Data.Generics.Twins.Qr r a -> r -> r
  [GblId[[RecSel]],
   Arity=1,
   Caf=NoCafRefs,
   Str=DmdType S,
   Unf=OtherCon []] =
      \r [eta_B1] Data.Generics.Twins.unQr1 eta_B1;,
  [(Data.Generics.Twins.unQr, [])]),
 (Data.Generics.Twins.$wgfoldlAccum
    :: forall a d (c :: * -> *).
       (forall (c1 :: * -> *).
        (forall d1 b. Data.Data.Data d1 => c1 (d1 -> b) -> d1 -> c1 b)
        -> (forall g. g -> c1 g) -> d -> c1 d)
       -> (forall e r.
           Data.Data.Data e =>
           a -> c (e -> r) -> e -> (a, c r))
       -> (forall g. a -> g -> (a, c g))
       -> a
       -> d
       -> (a, c d)
  [GblId,
   Arity=5,
   Caf=NoCafRefs,
   Str=DmdType SLLLL,
   Unf=OtherCon []] =
      \r [ww w w1 w2 w3]
          let {
            sat_s8o8 :: forall g. g -> Data.Generics.Twins.A a c g
            [LclId] =
                \r [f a] w1 a f; } in
          let {
            sat_s8o9
              :: forall d1 b.
                 Data.Data.Data d1 =>
                 Data.Generics.Twins.A a c (d1 -> b)
                 -> d1 -> Data.Generics.Twins.A a c b
            [LclId] =
                \r [$dData c y a]
                    let {
                      ds [Dmd=Just D(SS)] :: (a, c (d1 -> b))
                      [LclId, Str=DmdType] =
                          \u [] c a; } in
                    let {
                      sat_s8o4 :: c (d1 -> b)
                      [LclId] =
                          \u [] case ds of _ { (,) a' c' -> c'; }; } in
                    let {
                      sat_s8o5 :: a
                      [LclId] =
                          \u [] case ds of _ { (,) a' c' -> a'; };
                    } in  w $dData sat_s8o5 sat_s8o4 y;
          } in  ww sat_s8o9 sat_s8o8 w3 w2;,
  [(Data.Generics.Twins.$wgfoldlAccum, [])]),
 (Data.Generics.Twins.gfoldlAccum [InlPrag=INLINE[0]]
    :: forall a d (c :: * -> *).
       Data.Data.Data d =>
       (forall e r. Data.Data.Data e => a -> c (e -> r) -> e -> (a, c r))
       -> (forall g. a -> g -> (a, c g)) -> a -> d -> (a, c d)
  [GblId,
   Arity=5,
   Caf=NoCafRefs,
   Str=DmdType U(ASAAAAAAAAAAAAA)LLLL,
   Unf=OtherCon []] =
      \r [w w1 w2 w3 w4]
          case w of _ {
            Data.Data.D:Data ww
                             ww1
                             ww2
                             ww3
                             ww4
                             ww5
                             ww6
                             ww7
                             ww8
                             ww9
                             ww10
                             ww11
                             ww12
                             ww13
                             ww14 ->
                Data.Generics.Twins.$wgfoldlAccum ww1 w1 w2 w3 w4;
          };,
  [(Data.Generics.Twins.gfoldlAccum, [])]),
 (Data.Generics.Twins.$wgmapAccumA
    :: forall b d (a :: * -> *).
       (forall (c :: * -> *).
        (forall d1 b1. Data.Data.Data d1 => c (d1 -> b1) -> d1 -> c b1)
        -> (forall g. g -> c g) -> d -> c d)
       -> Control.Applicative.Applicative a =>
          (forall e. Data.Data.Data e => b -> e -> (b, a e))
          -> b -> d -> (b, a d)
  [GblId,
   Arity=5,
   Caf=NoCafRefs,
   Str=DmdType SLLLL,
   Unf=OtherCon []] =
      \r [ww w w1 w2 w3]
          let {
            lvl3 :: forall g. g -> a g
            [LclId] =
                \u [] Control.Applicative.pure w; } in
          let {
            lvl4 :: forall d1 b1. a (d1 -> b1) -> a d1 -> a b1
            [LclId] =
                \u [] Control.Applicative.<*> w; } in
          let {
            sat_s8oO :: forall g. g -> Data.Generics.Twins.A b a g
            [LclId] =
                \r [f a]
                    let {
                      sat_s8oH :: a g
                      [LclId] =
                          \u [] lvl3 f;
                    } in  (,) [a sat_s8oH]; } in
          let {
            sat_s8oP
              :: forall d1 b1.
                 Data.Data.Data d1 =>
                 Data.Generics.Twins.A b a (d1 -> b1)
                 -> d1 -> Data.Generics.Twins.A b a b1
            [LclId] =
                \r [$dData c y a]
                    let {
                      ds [Dmd=Just D(SS)] :: (b, a (d1 -> b1))
                      [LclId, Str=DmdType] =
                          \u [] c a; } in
                    let {
                      ds1 [Dmd=Just D(SS)] :: (b, a d1)
                      [LclId, Str=DmdType] =
                          \u []
                              let {
                                sat_s8ak :: b
                                [LclId] =
                                    \u [] case ds of _ { (,) a' c' -> a'; };
                              } in  w1 $dData sat_s8ak y; } in
                    let {
                      sat_s8oJ :: a b1
                      [LclId] =
                          \u []
                              let {
                                sat_s8aB :: a d1
                                [LclId] =
                                    \u [] case ds1 of _ { (,) a' d' -> d'; }; } in
                              let {
                                sat_s8aC :: a (d1 -> b1)
                                [LclId] =
                                    \u [] case ds of _ { (,) a' c' -> c'; };
                              } in  lvl4 sat_s8aC sat_s8aB; } in
                    let {
                      sat_s8oK :: b
                      [LclId] =
                          \u [] case ds1 of _ { (,) a' d' -> a'; };
                    } in  (,) [sat_s8oK sat_s8oJ];
          } in  ww sat_s8oP sat_s8oO w3 w2;,
  [(Data.Generics.Twins.$wgmapAccumA, [])]),
 (Data.Generics.Twins.gmapAccumA [InlPrag=INLINE[0]]
    :: forall b d (a :: * -> *).
       (Data.Data.Data d, Control.Applicative.Applicative a) =>
       (forall e. Data.Data.Data e => b -> e -> (b, a e))
       -> b -> d -> (b, a d)
  [GblId,
   Arity=5,
   Caf=NoCafRefs,
   Str=DmdType U(ASAAAAAAAAAAAAA)LLLL,
   Unf=OtherCon []] =
      \r [w w1 w2 w3 w4]
          case w of _ {
            Data.Data.D:Data ww
                             ww1
                             ww2
                             ww3
                             ww4
                             ww5
                             ww6
                             ww7
                             ww8
                             ww9
                             ww10
                             ww11
                             ww12
                             ww13
                             ww14 ->
                Data.Generics.Twins.$wgmapAccumA ww1 w1 w2 w3 w4;
          };,
  [(Data.Generics.Twins.gmapAccumA, [])]),
 (Data.Generics.Twins.$wgmapAccumM
    :: forall a d (m :: * -> *).
       (forall (c :: * -> *).
        (forall d1 b. Data.Data.Data d1 => c (d1 -> b) -> d1 -> c b)
        -> (forall g. g -> c g) -> d -> c d)
       -> GHC.Base.Monad m =>
          (forall e. Data.Data.Data e => a -> e -> (a, m e))
          -> a -> d -> (a, m d)
  [GblId,
   Arity=5,
   Caf=NoCafRefs,
   Str=DmdType SLLLL,
   Unf=OtherCon []] =
      \r [ww w w1 w2 w3]
          let {
            lvl3 :: forall b. b -> m b
            [LclId] =
                \u [] GHC.Base.return w; } in
          let {
            lvl4 :: forall d1 b. m (d1 -> b) -> ((d1 -> b) -> m b) -> m b
            [LclId] =
                \u [] GHC.Base.>>= w; } in
          let {
            lvl5 :: forall d1 b. m d1 -> (d1 -> m b) -> m b
            [LclId] =
                \u [] GHC.Base.>>= w; } in
          let {
            sat_s8pK :: forall g. g -> Data.Generics.Twins.A a m g
            [LclId] =
                \r [f a]
                    let {
                      sat_s8pB :: m g
                      [LclId] =
                          \u [] lvl3 f;
                    } in  (,) [a sat_s8pB]; } in
          let {
            sat_s8pL
              :: forall d1 b.
                 Data.Data.Data d1 =>
                 Data.Generics.Twins.A a m (d1 -> b)
                 -> d1 -> Data.Generics.Twins.A a m b
            [LclId] =
                \r [$dData c y a]
                    let {
                      ds [Dmd=Just D(SS)] :: (a, m (d1 -> b))
                      [LclId, Str=DmdType] =
                          \u [] c a; } in
                    let {
                      ds1 [Dmd=Just D(SS)] :: (a, m d1)
                      [LclId, Str=DmdType] =
                          \u []
                              let {
                                sat_s8bI :: a
                                [LclId] =
                                    \u [] case ds of _ { (,) a' c' -> a'; };
                              } in  w1 $dData sat_s8bI y; } in
                    let {
                      sat_s8pF :: m b
                      [LclId] =
                          \u []
                              let {
                                c1 [Dmd=Just L] :: m (d1 -> b)
                                [LclId, Str=DmdType] =
                                    \u [] case ds of _ { (,) a' c' -> c'; }; } in
                              let {
                                sat_s8c7 :: d1 -> m b
                                [LclId] =
                                    \r [d'']
                                        let {
                                          sat_s8pD :: (d1 -> b) -> m b
                                          [LclId] =
                                              \r [c']
                                                  let {
                                                    sat_s8pC :: b
                                                    [LclId] =
                                                        \u [] c' d'';
                                                  } in  lvl3 sat_s8pC;
                                        } in  lvl4 c1 sat_s8pD; } in
                              let {
                                sat_s8c8 :: m d1
                                [LclId] =
                                    \u [] case ds1 of _ { (,) a' d' -> d'; };
                              } in  lvl5 sat_s8c8 sat_s8c7; } in
                    let {
                      sat_s8pG :: a
                      [LclId] =
                          \u [] case ds1 of _ { (,) a' d' -> a'; };
                    } in  (,) [sat_s8pG sat_s8pF];
          } in  ww sat_s8pL sat_s8pK w3 w2;,
  [(Data.Generics.Twins.$wgmapAccumM, [])]),
 (Data.Generics.Twins.gmapAccumM [InlPrag=INLINE[0]]
    :: forall a d (m :: * -> *).
       (Data.Data.Data d, GHC.Base.Monad m) =>
       (forall e. Data.Data.Data e => a -> e -> (a, m e))
       -> a -> d -> (a, m d)
  [GblId,
   Arity=5,
   Caf=NoCafRefs,
   Str=DmdType U(ASAAAAAAAAAAAAA)LLLL,
   Unf=OtherCon []] =
      \r [w w1 w2 w3 w4]
          case w of _ {
            Data.Data.D:Data ww
                             ww1
                             ww2
                             ww3
                             ww4
                             ww5
                             ww6
                             ww7
                             ww8
                             ww9
                             ww10
                             ww11
                             ww12
                             ww13
                             ww14 ->
                Data.Generics.Twins.$wgmapAccumM ww1 w1 w2 w3 w4;
          };,
  [(Data.Generics.Twins.gmapAccumM, [])]),
 (Data.Generics.Twins.$wgmapAccumQl
    :: forall r r' a d.
       Data.Data.Data d =>
       (r -> r' -> r)
       -> r
       -> (forall e. Data.Data.Data e => a -> e -> (a, r'))
       -> a
       -> d
       -> (# a, r #)
  [GblId,
   Arity=6,
   Caf=NoCafRefs,
   Str=DmdType LLLLLL,
   Unf=OtherCon []] =
      \r [w w1 w2 w3 w4 w5]
          let {
            ds [Dmd=Just D(SS)] :: (a, Data.Generics.Twins.CONST r d)
            [LclId, Str=DmdType] =
                \u []
                    let {
                      sat_s8dF
                        :: forall g.
                           g -> Data.Generics.Twins.A a (Data.Generics.Twins.CONST r) g
                      [LclId] =
                          \r [f a] (,) [a w2]; } in
                    let {
                      sat_s8dE
                        :: forall d b.
                           Data.Data.Data d =>
                           Data.Generics.Twins.A a (Data.Generics.Twins.CONST r) (d -> b)
                           -> d -> Data.Generics.Twins.A a (Data.Generics.Twins.CONST r) b
                      [LclId] =
                          \r [$dData c y a]
                              let {
                                ds1 [Dmd=Just D(SS)] :: (a, Data.Generics.Twins.CONST r (d1 -> b))
                                [LclId, Str=DmdType] =
                                    \u [] c a; } in
                              let {
                                ds2 [Dmd=Just D(SS)] :: (a, r')
                                [LclId, Str=DmdType] =
                                    \u []
                                        let {
                                          sat_s8da :: a
                                          [LclId] =
                                              \u [] case ds1 of _ { (,) a' c' -> a'; };
                                        } in  w3 $dData sat_s8da y; } in
                              let {
                                sat_s8qA :: Data.Generics.Twins.CONST r b
                                [LclId] =
                                    \u []
                                        let {
                                          sat_s8ds :: r'
                                          [LclId] =
                                              \u [] case ds2 of _ { (,) a' r -> r; }; } in
                                        let {
                                          sat_s8dt :: r
                                          [LclId] =
                                              \u [] case ds1 of _ { (,) a' c' -> c'; };
                                        } in  w1 sat_s8dt sat_s8ds; } in
                              let {
                                sat_s8qB :: a
                                [LclId] =
                                    \u [] case ds2 of _ { (,) a' r -> a'; };
                              } in  (,) [sat_s8qB sat_s8qA];
                    } in  Data.Data.gfoldl w sat_s8dE sat_s8dF w5 w4; } in
          let {
            sat_s8qF :: r
            [LclId] =
                \u [] case ds of _ { (,) a1 r1 -> r1; }; } in
          let {
            sat_s8qG :: a
            [LclId] =
                \u [] case ds of _ { (,) a1 r1 -> a1; };
          } in  (#,#) [sat_s8qG sat_s8qF];,
  [(Data.Generics.Twins.$wgmapAccumQl, [])]),
 (Data.Generics.Twins.gmapAccumQl [InlPrag=INLINE[0]]
    :: forall r r' a d.
       Data.Data.Data d =>
       (r -> r' -> r)
       -> r
       -> (forall e. Data.Data.Data e => a -> e -> (a, r'))
       -> a
       -> d
       -> (a, r)
  [GblId,
   Arity=6,
   Caf=NoCafRefs,
   Str=DmdType LLLLLLm,
   Unf=OtherCon []] =
      \r [w w1 w2 w3 w4 w5]
          case Data.Generics.Twins.$wgmapAccumQl w w1 w2 w3 w4 w5 of _ {
            (#,#) ww1 ww2 -> (,) [ww1 ww2];
          };,
  [(Data.Generics.Twins.gmapAccumQl, [])]),
 (Data.Generics.Twins.gmapAccumQr1
    :: forall r a g. g -> a -> (a, Data.Generics.Twins.Qr r g)
  [GblId, Arity=2, Caf=NoCafRefs, Unf=OtherCon []] =
      \r [f a] (,) [a GHC.Base.id];,
  [(Data.Generics.Twins.gmapAccumQr1, [])]),
 (Data.Generics.Twins.$wgmapAccumQr
    :: forall r' r a d.
       Data.Data.Data d =>
       (r' -> r -> r)
       -> r
       -> (forall e. Data.Data.Data e => a -> e -> (a, r'))
       -> a
       -> d
       -> (# a, r #)
  [GblId,
   Arity=6,
   Caf=NoCafRefs,
   Str=DmdType LLLLLL,
   Unf=OtherCon []] =
      \r [w w1 w2 w3 w4 w5]
          let {
            ds [Dmd=Just D(SC(S))] :: (a, Data.Generics.Twins.Qr r d)
            [LclId, Str=DmdType] =
                \u []
                    let {
                      sat_s8f0
                        :: forall d b.
                           Data.Data.Data d =>
                           Data.Generics.Twins.A a (Data.Generics.Twins.Qr r) (d -> b)
                           -> d -> Data.Generics.Twins.A a (Data.Generics.Twins.Qr r) b
                      [LclId] =
                          \r [$dData c y a]
                              let {
                                ds1 [Dmd=Just D(SC(S))] :: (a, Data.Generics.Twins.Qr r (d1 -> b))
                                [LclId, Str=DmdType] =
                                    \u [] c a; } in
                              let {
                                ds2 [Dmd=Just D(SS)] :: (a, r')
                                [LclId, Str=DmdType] =
                                    \u []
                                        let {
                                          sat_s8eB :: a
                                          [LclId] =
                                              \u [] case ds1 of _ { (,) a' c' -> a'; };
                                        } in  w3 $dData sat_s8eB y; } in
                              let {
                                r' [Dmd=Just L] :: r'
                                [LclId, Str=DmdType] =
                                    \u [] case ds2 of _ { (,) a' r'1 -> r'1; }; } in
                              let {
                                sat_s8ro :: Data.Generics.Twins.Qr r b
                                [LclId] =
                                    \r [r]
                                        case ds1 of _ {
                                          (,) a' c' ->
                                              let {
                                                sat_s8rn :: r
                                                [LclId] =
                                                    \u [] w1 r' r;
                                              } in  c' sat_s8rn;
                                        }; } in
                              let {
                                sat_s8rp :: a
                                [LclId] =
                                    \u [] case ds2 of _ { (,) a' r'1 -> a'; };
                              } in  (,) [sat_s8rp sat_s8ro];
                    } in 
                      Data.Data.gfoldl
                          w sat_s8f0 Data.Generics.Twins.gmapAccumQr1 w5 w4; } in
          let {
            sat_s8ru :: r
            [LclId] =
                \u [] case ds of _ { (,) a1 l -> l w2; }; } in
          let {
            sat_s8rv :: a
            [LclId] =
                \u [] case ds of _ { (,) a1 l -> a1; };
          } in  (#,#) [sat_s8rv sat_s8ru];,
  [(Data.Generics.Twins.$wgmapAccumQr, [])]),
 (Data.Generics.Twins.gmapAccumQr [InlPrag=INLINE[0]]
    :: forall r' r a d.
       Data.Data.Data d =>
       (r' -> r -> r)
       -> r
       -> (forall e. Data.Data.Data e => a -> e -> (a, r'))
       -> a
       -> d
       -> (a, r)
  [GblId,
   Arity=6,
   Caf=NoCafRefs,
   Str=DmdType LLLLLLm,
   Unf=OtherCon []] =
      \r [w w1 w2 w3 w4 w5]
          case Data.Generics.Twins.$wgmapAccumQr w w1 w2 w3 w4 w5 of _ {
            (#,#) ww1 ww2 -> (,) [ww1 ww2];
          };,
  [(Data.Generics.Twins.gmapAccumQr, [])]),
 (Data.Generics.Twins.gmapAccumQ
    :: forall a d q.
       Data.Data.Data d =>
       (forall e. Data.Data.Data e => a -> e -> (a, q))
       -> a -> d -> (a, [q])
  [GblId,
   Arity=4,
   Caf=NoCafRefs,
   Str=DmdType LLLLm,
   Unf=OtherCon []] =
      \r [$dData f eta eta1]
          case
              Data.Generics.Twins.$wgmapAccumQr
                  $dData GHC.Types.: GHC.Types.[] f eta eta1
          of
          _
          { (#,#) ww1 ww2 -> (,) [ww1 ww2];
          };,
  [(Data.Generics.Twins.gmapAccumQ, [])]),
 (Data.Generics.Twins.gmapAccumT1
    :: forall a g. g -> a -> (a, Data.Generics.Twins.ID g)
  [GblId, Arity=2, Caf=NoCafRefs, Unf=OtherCon []] =
      \r [f a] (,) [a f];,
  [(Data.Generics.Twins.gmapAccumT1, [])]),
 (Data.Generics.Twins.$wgmapAccumT
    :: forall a d.
       Data.Data.Data d =>
       (forall e. Data.Data.Data e => a -> e -> (a, e))
       -> a -> d -> (# a, d #)
  [GblId,
   Arity=4,
   Caf=NoCafRefs,
   Str=DmdType LLLL,
   Unf=OtherCon []] =
      \r [w w1 w2 w3]
          let {
            ds [Dmd=Just D(SS)] :: (a, Data.Generics.Twins.ID d)
            [LclId, Str=DmdType] =
                \u []
                    let {
                      sat_s8gs
                        :: forall d b.
                           Data.Data.Data d =>
                           Data.Generics.Twins.A a Data.Generics.Twins.ID (d -> b)
                           -> d -> Data.Generics.Twins.A a Data.Generics.Twins.ID b
                      [LclId] =
                          \r [$dData c y a]
                              let {
                                ds1 [Dmd=Just D(SC(S))] :: (a, Data.Generics.Twins.ID (d1 -> b))
                                [LclId, Str=DmdType] =
                                    \u [] c a; } in
                              let {
                                ds2 [Dmd=Just D(SS)] :: (a, d1)
                                [LclId, Str=DmdType] =
                                    \u []
                                        let {
                                          sat_s8g8 :: a
                                          [LclId] =
                                              \u [] case ds1 of _ { (,) a' c' -> a'; };
                                        } in  w1 $dData sat_s8g8 y; } in
                              let {
                                sat_s8sd :: Data.Generics.Twins.ID b
                                [LclId] =
                                    \u []
                                        case ds1 of _ {
                                          (,) a' c' ->
                                              let {
                                                sat_s8sc :: d1
                                                [LclId] =
                                                    \u [] case ds2 of _ { (,) a'1 d' -> d'; };
                                              } in  c' sat_s8sc;
                                        }; } in
                              let {
                                sat_s8se :: a
                                [LclId] =
                                    \u [] case ds2 of _ { (,) a' d' -> a'; };
                              } in  (,) [sat_s8se sat_s8sd];
                    } in 
                      Data.Data.gfoldl
                          w sat_s8gs Data.Generics.Twins.gmapAccumT1 w3 w2; } in
          let {
            sat_s8sj :: d
            [LclId] =
                \u [] case ds of _ { (,) a1 d1 -> d1; }; } in
          let {
            sat_s8sk :: a
            [LclId] =
                \u [] case ds of _ { (,) a1 d1 -> a1; };
          } in  (#,#) [sat_s8sk sat_s8sj];,
  [(Data.Generics.Twins.$wgmapAccumT, [])]),
 (Data.Generics.Twins.gmapAccumT [InlPrag=INLINE[0]]
    :: forall a d.
       Data.Data.Data d =>
       (forall e. Data.Data.Data e => a -> e -> (a, e))
       -> a -> d -> (a, d)
  [GblId,
   Arity=4,
   Caf=NoCafRefs,
   Str=DmdType LLLLm,
   Unf=OtherCon []] =
      \r [w w1 w2 w3]
          case Data.Generics.Twins.$wgmapAccumT w w1 w2 w3 of _ {
            (#,#) ww1 ww2 -> (,) [ww1 ww2];
          };,
  [(Data.Generics.Twins.gmapAccumT, [])]),
 (lvl :: [GHC.Types.Char]
  [GblId] =
      \u [] GHC.CString.unpackCString# "gzipWithM";,
  [(lvl, [])]),
 (Data.Generics.Twins.gzipWithM1 :: forall a. Data.Maybe.Maybe a
  [GblId, Str=DmdType b] =
      \u srt:(0,*bitmap*) [] GHC.Err.error lvl;,
  [(Data.Generics.Twins.gzipWithM1, [GHC.Err.error, lvl])]),
 (Data.Generics.Twins.gzipWithM2
    :: forall a.
       Data.Data.Data a =>
       [Data.Generics.Aliases.GenericM' Data.Maybe.Maybe]
       -> a
       -> ([Data.Generics.Aliases.GenericM' Data.Maybe.Maybe],
           Data.Maybe.Maybe a)
  [GblId, Arity=3, Str=DmdType LLLm, Unf=OtherCon []] =
      \r srt:(0,*bitmap*) [$dData a d]
          let {
            sat_s8sY :: Data.Maybe.Maybe a
            [LclId] =
                \u srt:(0,*bitmap*) []
                    case a of _ {
                      [] -> GHC.List.badHead;
                      : x ds1 -> x $dData d;
                    }; } in
          let {
            sat_s8sZ :: [Data.Generics.Aliases.GenericM' Data.Maybe.Maybe]
            [LclId] =
                \u srt:(1,*bitmap*) []
                    case a of _ {
                      [] -> GHC.List.tail1;
                      : ds1 xs -> xs;
                    };
          } in  (,) [sat_s8sZ sat_s8sY];,
  [(Data.Generics.Twins.gzipWithM2,
    [GHC.List.badHead, GHC.List.tail1])]),
 (Data.Generics.Twins.$w$sgzipWithM
    :: Data.Generics.Aliases.GenericQ
         (Data.Generics.Aliases.GenericM Data.Maybe.Maybe)
       -> forall a.
          Data.Data.Data a =>
          a
          -> forall a1.
             (forall (c :: * -> *).
              (forall d b. Data.Data.Data d => c (d -> b) -> d -> c b)
              -> (forall g. g -> c g) -> a1 -> c a1)
             -> a1 -> Data.Maybe.Maybe a1
  [GblId, Arity=5, Str=DmdType LLLSL, Unf=OtherCon []] =
      \r srt:(0,*bitmap*) [w w1 w2 ww w3]
          let {
            sat_s8t4 :: [Data.Generics.Aliases.GenericM' Data.Maybe.Maybe]
            [LclId] =
                \u []
                    let {
                      sat_s8ho
                        :: forall d.
                           Data.Data.Data d =>
                           d -> Data.Generics.Aliases.GenericM' Data.Maybe.Maybe
                      [LclId] =
                          \r [$dData k $dData1] w $dData k $dData1;
                    } in  Data.Data.gmapQ w1 sat_s8ho w2;
          } in 
            case
                Data.Generics.Twins.$wgmapAccumM
                    ww
                    Data.Maybe.$fMonadMaybe
                    Data.Generics.Twins.gzipWithM2
                    sat_s8t4
                    w3
            of
            _
            { (,) ds c ->
                  case ds of _ {
                    [] -> c;
                    : ipv ipv1 -> Data.Generics.Twins.gzipWithM1;
                  };
            };,
  [(Data.Generics.Twins.$w$sgzipWithM,
    [Data.Generics.Twins.gzipWithM1,
     Data.Generics.Twins.gzipWithM2])]),
 (Data.Generics.Twins.gzipWithM_$sgzipWithM [InlPrag=INLINE[0]]
    :: Data.Generics.Aliases.GenericQ
         (Data.Generics.Aliases.GenericM Data.Maybe.Maybe)
       -> Data.Generics.Aliases.GenericQ
            (Data.Generics.Aliases.GenericM Data.Maybe.Maybe)
  [GblId,
   Arity=5,
   Str=DmdType LLLU(ASAAAAAAAAAAAAA)L,
   Unf=OtherCon []] =
      \r srt:(0,*bitmap*) [w w1 w2 w3 w4]
          case w3 of _ {
            Data.Data.D:Data ww
                             ww1
                             ww2
                             ww3
                             ww4
                             ww5
                             ww6
                             ww7
                             ww8
                             ww9
                             ww10
                             ww11
                             ww12
                             ww13
                             ww14 ->
                Data.Generics.Twins.$w$sgzipWithM w w1 w2 ww1 w4;
          };,
  [(Data.Generics.Twins.gzipWithM_$sgzipWithM,
    [Data.Generics.Twins.$w$sgzipWithM])]),
 (Data.Generics.Twins.gzipWithM3 :: forall a (m :: * -> *). m a
  [GblId, Str=DmdType b] =
      \u srt:(0,*bitmap*) [] GHC.Err.error lvl;,
  [(Data.Generics.Twins.gzipWithM3, [GHC.Err.error, lvl])]),
 (Data.Generics.Twins.gzipWithM4
    :: forall (m :: * -> *) a.
       Data.Data.Data a =>
       [Data.Generics.Aliases.GenericM' m]
       -> a -> ([Data.Generics.Aliases.GenericM' m], m a)
  [GblId, Arity=3, Str=DmdType LLLm, Unf=OtherCon []] =
      \r srt:(0,*bitmap*) [$dData a d]
          let {
            sat_s8to :: m a
            [LclId] =
                \u srt:(0,*bitmap*) []
                    case a of _ {
                      [] -> GHC.List.badHead;
                      : x ds1 -> x $dData d;
                    }; } in
          let {
            sat_s8tp :: [Data.Generics.Aliases.GenericM' m]
            [LclId] =
                \u srt:(1,*bitmap*) []
                    case a of _ {
                      [] -> GHC.List.tail1;
                      : ds1 xs -> xs;
                    };
          } in  (,) [sat_s8tp sat_s8to];,
  [(Data.Generics.Twins.gzipWithM4,
    [GHC.List.badHead, GHC.List.tail1])]),
 (Data.Generics.Twins.$wgzipWithM
    :: forall (m :: * -> *).
       GHC.Base.Monad m =>
       Data.Generics.Aliases.GenericQ (Data.Generics.Aliases.GenericM m)
       -> forall a.
          Data.Data.Data a =>
          a
          -> forall a1.
             (forall (c :: * -> *).
              (forall d b. Data.Data.Data d => c (d -> b) -> d -> c b)
              -> (forall g. g -> c g) -> a1 -> c a1)
             -> a1 -> m a1
  [GblId, Arity=6, Str=DmdType LLLLSL, Unf=OtherCon []] =
      \r srt:(0,*bitmap*) [w w1 w2 w3 ww w4]
          let {
            sat_s8tu :: [Data.Generics.Aliases.GenericM' m]
            [LclId] =
                \u []
                    let {
                      sat_s8iz
                        :: forall d.
                           Data.Data.Data d =>
                           d -> Data.Generics.Aliases.GenericM' m
                      [LclId] =
                          \r [$dData k $dData1] w1 $dData k $dData1;
                    } in  Data.Data.gmapQ w2 sat_s8iz w3;
          } in 
            case
                Data.Generics.Twins.$wgmapAccumM
                    ww w Data.Generics.Twins.gzipWithM4 sat_s8tu w4
            of
            _
            { (,) ds c ->
                  case ds of _ {
                    [] -> c;
                    : ipv ipv1 -> Data.Generics.Twins.gzipWithM3;
                  };
            };,
  [(Data.Generics.Twins.$wgzipWithM,
    [Data.Generics.Twins.gzipWithM3,
     Data.Generics.Twins.gzipWithM4])]),
 (Data.Generics.Twins.gzipWithM [InlPrag=INLINE[0]]
    :: forall (m :: * -> *).
       GHC.Base.Monad m =>
       Data.Generics.Aliases.GenericQ (Data.Generics.Aliases.GenericM m)
       -> Data.Generics.Aliases.GenericQ
            (Data.Generics.Aliases.GenericM m)
  [GblId,
   Arity=6,
   Str=DmdType LLLLU(ASAAAAAAAAAAAAA)L,
   Unf=OtherCon []] =
      \r srt:(0,*bitmap*) [w w1 w2 w3 w4 w5]
          case w4 of _ {
            Data.Data.D:Data ww
                             ww1
                             ww2
                             ww3
                             ww4
                             ww5
                             ww6
                             ww7
                             ww8
                             ww9
                             ww10
                             ww11
                             ww12
                             ww13
                             ww14 ->
                Data.Generics.Twins.$wgzipWithM w w1 w2 w3 ww1 w5;
          };,
  [(Data.Generics.Twins.gzipWithM,
    [Data.Generics.Twins.$wgzipWithM])]),
 (Data.Generics.Twins.gzip [Occ=LoopBreaker]
    :: Data.Generics.Aliases.GenericQ
         (Data.Generics.Aliases.GenericM Data.Maybe.Maybe)
       -> Data.Generics.Aliases.GenericQ
            (Data.Generics.Aliases.GenericM Data.Maybe.Maybe)
  [GblId, Arity=5, Str=DmdType C(C(C(C(S))))LLLL, Unf=OtherCon []] =
      \r srt:(0,*bitmap*) [dk $dData dk1 $dData1 y]
          case dk $dData dk1 $dData1 y of wild {
            Data.Maybe.Nothing ->
                case Data.Data.toConstr $dData dk1 of _ {
                  Data.Data.Constr ds _ _ _ _ ->
                      case Data.Data.toConstr $dData1 y of _ {
                        Data.Data.Constr ds5 _ _ _ _ ->
                            case Data.Data.$fEqConstr_$c==1 ds ds5 of _ {
                              GHC.Types.False -> Data.Maybe.Nothing [];
                              GHC.Types.True ->
                                  case $dData1 of _ {
                                    Data.Data.D:Data ww
                                                     ww1
                                                     ww2
                                                     ww3
                                                     ww4
                                                     ww5
                                                     ww6
                                                     ww7
                                                     ww8
                                                     ww9
                                                     ww10
                                                     ww11
                                                     ww12
                                                     ww13
                                                     ww14 ->
                                        let {
                                          sat_s8tZ
                                            :: [Data.Generics.Aliases.GenericM' Data.Maybe.Maybe]
                                          [LclId] =
                                              \u srt:(2,*bitmap*) []
                                                  let {
                                                    lvl3
                                                      :: forall a2.
                                                         Data.Data.Data a2 =>
                                                         a2
                                                         -> forall a3.
                                                            Data.Data.Data a3 =>
                                                            a3 -> Data.Maybe.Maybe a3
                                                    [LclId,
                                                     Arity=3,
                                                     Str=DmdType LLL,
                                                     Unf=OtherCon []] =
                                                        \r [$dData2 dk2 $dData3]
                                                            dk $dData2 dk2 $dData3; } in
                                                  let {
                                                    sat_s8k9
                                                      :: forall d.
                                                         Data.Data.Data d =>
                                                         d
                                                         -> Data.Generics.Aliases.GenericM'
                                                              Data.Maybe.Maybe
                                                    [LclId] =
                                                        \r srt:(2,*bitmap*) [$dData2
                                                                             k
                                                                             $dData3
                                                                             eta_B1]
                                                            Data.Generics.Twins.gzip
                                                                lvl3 $dData2 k $dData3 eta_B1;
                                                  } in  Data.Data.gmapQ $dData sat_s8k9 dk1;
                                        } in 
                                          case
                                              Data.Generics.Twins.$wgmapAccumM
                                                  ww1
                                                  Data.Maybe.$fMonadMaybe
                                                  Data.Generics.Twins.gzipWithM4
                                                  sat_s8tZ
                                                  y
                                          of
                                          _
                                          { (,) ds10 c ->
                                                case ds10 of _ {
                                                  [] -> c;
                                                  : ipv ipv1 -> Data.Generics.Twins.gzipWithM3;
                                                };
                                          };
                                  };
                            };
                      };
                };
            Data.Maybe.Just ds -> wild;
          };,
  [(Data.Generics.Twins.gzip,
    [Data.Generics.Twins.gzipWithM3, Data.Generics.Twins.gzipWithM4,
     Data.Generics.Twins.gzip])]),
 (lvl1 :: [GHC.Types.Char]
  [GblId] =
      \u [] GHC.CString.unpackCString# "gzipWithQ";,
  [(lvl1, [])]),
 (Data.Generics.Twins.gzipWithQ1 :: forall r. [r]
  [GblId, Str=DmdType b] =
      \u srt:(0,*bitmap*) [] GHC.Err.error lvl1;,
  [(Data.Generics.Twins.gzipWithQ1, [GHC.Err.error, lvl1])]),
 (Data.Generics.Twins.gzipWithQ3
    :: forall r d b.
       Data.Data.Data d =>
       Data.Generics.Twins.A
         [Data.Generics.Aliases.GenericQ' r]
         (Data.Generics.Twins.Qr [r])
         (d -> b)
       -> d
       -> [Data.Generics.Aliases.GenericQ' r]
       -> ([Data.Generics.Aliases.GenericQ' r],
           Data.Generics.Twins.Qr [r] b)
  [GblId, Arity=4, Unf=OtherCon []] =
      \r srt:(0,*bitmap*) [$dData c y a]
          let {
            ds [Dmd=Just D(SC(S))]
              :: ([Data.Generics.Aliases.GenericQ' r],
                  Data.Generics.Twins.Qr [r] (d -> b))
            [LclId, Str=DmdType] =
                \u [] c a; } in
          let {
            a1 [Dmd=Just L] :: [Data.Generics.Aliases.GenericQ' r]
            [LclId, Str=DmdType] =
                \u [] case ds of _ { (,) a' c' -> a'; }; } in
          let {
            a2 [Dmd=Just L] :: r
            [LclId, Str=DmdType] =
                \u srt:(0,*bitmap*) []
                    case a1 of _ {
                      [] -> GHC.List.badHead;
                      : x ds1 -> x $dData y;
                    }; } in
          let {
            sat_s8ul :: Data.Generics.Twins.Qr [r] b
            [LclId] =
                \r [r]
                    case ds of _ {
                      (,) a' c' ->
                          let {
                            sat_s8uk :: [r]
                            [LclId] =
                                NO_CCS :! [a2 r];
                          } in  c' sat_s8uk;
                    }; } in
          let {
            sat_s8um :: [Data.Generics.Aliases.GenericQ' r]
            [LclId] =
                \u srt:(1,*bitmap*) []
                    case a1 of _ {
                      [] -> GHC.List.tail1;
                      : ds1 xs -> xs;
                    };
          } in  (,) [sat_s8um sat_s8ul];,
  [(Data.Generics.Twins.gzipWithQ3,
    [GHC.List.badHead, GHC.List.tail1])]),
 (Data.Generics.Twins.gzipWithQ2
    :: forall r g.
       g
       -> [Data.Generics.Aliases.GenericQ' r]
       -> ([Data.Generics.Aliases.GenericQ' r],
           Data.Generics.Twins.Qr [r] g)
  [GblId, Arity=2, Caf=NoCafRefs, Unf=OtherCon []] =
      \r [f a] (,) [a GHC.Base.id];,
  [(Data.Generics.Twins.gzipWithQ2, [])]),
 (Data.Generics.Twins.$wgzipWithQ
    :: forall r.
       Data.Generics.Aliases.GenericQ (Data.Generics.Aliases.GenericQ r)
       -> forall a.
          Data.Data.Data a =>
          a
          -> forall a1.
             (forall (c :: * -> *).
              (forall d b. Data.Data.Data d => c (d -> b) -> d -> c b)
              -> (forall g. g -> c g) -> a1 -> c a1)
             -> a1 -> [r]
  [GblId, Arity=5, Str=DmdType LLLSL, Unf=OtherCon []] =
      \r srt:(0,*bitmap*) [w w1 w2 ww w3]
          let {
            sat_s8uv :: [Data.Generics.Aliases.GenericQ' r]
            [LclId] =
                \u []
                    let {
                      sat_s8lf
                        :: forall d.
                           Data.Data.Data d =>
                           d -> Data.Generics.Aliases.GenericQ' r
                      [LclId] =
                          \r [$dData k $dData1] w $dData k $dData1;
                    } in  Data.Data.gmapQ w1 sat_s8lf w2;
          } in 
            case
                ww  Data.Generics.Twins.gzipWithQ3
                    Data.Generics.Twins.gzipWithQ2
                    w3
                    sat_s8uv
            of
            _
            { (,) a1 l ->
                  case a1 of _ {
                    [] -> l GHC.Types.[];
                    : ipv ipv1 -> Data.Generics.Twins.gzipWithQ1;
                  };
            };,
  [(Data.Generics.Twins.$wgzipWithQ,
    [Data.Generics.Twins.gzipWithQ1,
     Data.Generics.Twins.gzipWithQ3])]),
 (Data.Generics.Twins.gzipWithQ [InlPrag=INLINE[0]]
    :: forall r.
       Data.Generics.Aliases.GenericQ (Data.Generics.Aliases.GenericQ r)
       -> Data.Generics.Aliases.GenericQ
            (Data.Generics.Aliases.GenericQ [r])
  [GblId,
   Arity=5,
   Str=DmdType LLLU(ASAAAAAAAAAAAAA)L,
   Unf=OtherCon []] =
      \r srt:(0,*bitmap*) [w w1 w2 w3 w4]
          case w3 of _ {
            Data.Data.D:Data ww
                             ww1
                             ww2
                             ww3
                             ww4
                             ww5
                             ww6
                             ww7
                             ww8
                             ww9
                             ww10
                             ww11
                             ww12
                             ww13
                             ww14 ->
                Data.Generics.Twins.$wgzipWithQ w w1 w2 ww1 w4;
          };,
  [(Data.Generics.Twins.gzipWithQ,
    [Data.Generics.Twins.$wgzipWithQ])]),
 (Data.Generics.Twins.geq_geq' [InlPrag=INLINE[0]]
    :: Data.Generics.Aliases.GenericQ
         (Data.Generics.Aliases.GenericQ GHC.Types.Bool)
  [GblId,
   Arity=4,
   Str=DmdType S(LLLSLLLLLLLLLLL)LU(ALASAAAAAAAAAAA)L,
   Unf=OtherCon []] =
      \r srt:(0,*bitmap*) [w w1 w2 w3]
          case w2 of _ {
            Data.Data.D:Data ww
                             ww1
                             ww2
                             ww3
                             ww4
                             ww5
                             ww6
                             ww7
                             ww8
                             ww9
                             ww10
                             ww11
                             ww12
                             ww13
                             ww14 ->
                Data.Generics.Twins.$wgeq' w w1 ww1 ww3 w3;
          };
  Data.Generics.Twins.$wgeq' [Occ=LoopBreaker]
    :: forall a.
       Data.Data.Data a =>
       a
       -> forall a1.
          (forall (c :: * -> *).
           (forall d b. Data.Data.Data d => c (d -> b) -> d -> c b)
           -> (forall g. g -> c g) -> a1 -> c a1)
          -> (a1 -> Data.Data.Constr) -> a1 -> GHC.Types.Bool
  [GblId,
   Arity=5,
   Str=DmdType S(LLLSLLLLLLLLLLL)LLSL,
   Unf=OtherCon []] =
      \r srt:(0,*bitmap*) [w w1 ww ww1 w2]
          case Data.Data.toConstr w w1 of _ {
            Data.Data.Constr ds _ _ _ _ ->
                case ww1 w2 of _ {
                  Data.Data.Constr ds5 _ _ _ _ ->
                      case Data.Data.$fEqConstr_$c==1 ds ds5 of _ {
                        GHC.Types.False -> GHC.Types.False [];
                        GHC.Types.True ->
                            let {
                              sat_s8vf :: [Data.Generics.Aliases.GenericQ' GHC.Types.Bool]
                              [LclId] =
                                  \u srt:(0,*bitmap*) []
                                      Data.Data.gmapQ w Data.Generics.Twins.geq_geq' w1;
                            } in 
                              case
                                  ww  Data.Generics.Twins.gzipWithQ3
                                      Data.Generics.Twins.gzipWithQ2
                                      w2
                                      sat_s8vf
                              of
                              _
                              { (,) a1 l ->
                                    case a1 of _ {
                                      [] ->
                                          case l GHC.Types.[] of sat_s8ve {
                                            __DEFAULT -> GHC.List.and sat_s8ve;
                                          };
                                      : ipv ipv1 -> Data.Generics.Twins.gzipWithQ1;
                                    };
                              };
                      };
                };
          };,
  [(Data.Generics.Twins.geq_geq', [Data.Generics.Twins.$wgeq']),
   (Data.Generics.Twins.$wgeq',
    [Data.Generics.Twins.geq_geq', Data.Generics.Twins.gzipWithQ1,
     Data.Generics.Twins.gzipWithQ3])]),
 (Data.Generics.Twins.geq
    :: forall a. Data.Data.Data a => a -> a -> GHC.Types.Bool
  [GblId,
   Arity=3,
   Str=DmdType S(LLLSLLLLLLLLLLL)LL,
   Unf=OtherCon []] =
      \r srt:(0,*bitmap*) [$dData x0 y0]
          Data.Generics.Twins.geq_geq' $dData x0 $dData y0;,
  [(Data.Generics.Twins.geq, [Data.Generics.Twins.geq_geq'])]),
 (lvl2 :: [GHC.Types.Char]
  [GblId] =
      \u [] GHC.CString.unpackCString# "gzipWithT";,
  [(lvl2, [])]),
 (Data.Generics.Twins.gzipWithT1 :: forall a. a
  [GblId, Str=DmdType b] =
      \u srt:(0,*bitmap*) [] GHC.Err.error lvl2;,
  [(Data.Generics.Twins.gzipWithT1, [GHC.Err.error, lvl2])]),
 (Data.Generics.Twins.gzipWithT
    :: Data.Generics.Aliases.GenericQ Data.Generics.Aliases.GenericT
       -> Data.Generics.Aliases.GenericQ Data.Generics.Aliases.GenericT
  [GblId, Arity=5, Str=DmdType LLLLL, Unf=OtherCon []] =
      \r srt:(0,*bitmap*) [dk $dData dk1 $dData1 y]
          let {
            sat_s8vr :: [Data.Generics.Aliases.GenericT']
            [LclId] =
                \u []
                    let {
                      sat_s8nL
                        :: forall d.
                           Data.Data.Data d =>
                           d -> Data.Generics.Aliases.GenericT'
                      [LclId] =
                          \r [$dData2 k $dData3] dk $dData2 k $dData3;
                    } in  Data.Data.gmapQ $dData sat_s8nL dk1; } in
          let {
            sat_s8vs
              :: forall d b.
                 Data.Data.Data d =>
                 Data.Generics.Twins.A
                   [Data.Generics.Aliases.GenericT'] Data.Generics.Twins.ID (d -> b)
                 -> d
                 -> Data.Generics.Twins.A
                      [Data.Generics.Aliases.GenericT'] Data.Generics.Twins.ID b
            [LclId] =
                \r srt:(0,*bitmap*) [$dData2 c y1 a]
                    let {
                      ds [Dmd=Just D(SC(S))]
                        :: ([Data.Generics.Aliases.GenericT'],
                            Data.Generics.Twins.ID (d -> b))
                      [LclId, Str=DmdType] =
                          \u [] c a; } in
                    let {
                      a1 [Dmd=Just L] :: [Data.Generics.Aliases.GenericT']
                      [LclId] =
                          \u [] case ds of _ { (,) a' c' -> a'; }; } in
                    let {
                      sat_s8vl :: Data.Generics.Twins.ID b
                      [LclId] =
                          \u srt:(0,*bitmap*) []
                              case ds of _ {
                                (,) a' c' ->
                                    let {
                                      sat_s8vk :: d
                                      [LclId] =
                                          \u srt:(0,*bitmap*) []
                                              case a1 of _ {
                                                [] -> GHC.List.badHead;
                                                : x ds1 -> x $dData2 y1;
                                              };
                                    } in  c' sat_s8vk;
                              }; } in
                    let {
                      sat_s8vm :: [Data.Generics.Aliases.GenericT']
                      [LclId] =
                          \u srt:(1,*bitmap*) []
                              case a1 of _ {
                                [] -> GHC.List.tail1;
                                : ds1 xs -> xs;
                              };
                    } in  (,) [sat_s8vm sat_s8vl];
          } in 
            case
                Data.Data.gfoldl
                    $dData1 sat_s8vs Data.Generics.Twins.gmapAccumT1 y sat_s8vr
            of
            _
            { (,) a1 d1 ->
                  case a1 of _ {
                    [] -> d1;
                    : ipv ipv1 -> Data.Generics.Twins.gzipWithT1;
                  };
            };,
  [(Data.Generics.Twins.gzipWithT,
    [GHC.List.badHead, GHC.List.tail1,
     Data.Generics.Twins.gzipWithT1])])]