==================== Tidy Core ====================
2016-01-28 18:07:21.820886 UTC

Result size of Tidy Core
  = {terms: 277, types: 1,339, coercions: 156}

Foo.$WL [InlPrag=INLINE] :: forall a_ana. a_ana -> Tree Z a_ana
[GblId[DataConWrapper],
 Arity=1,
 Caf=NoCafRefs,
 Str=DmdType <L,U>,
 Unf=Unf{Src=InlineStable, TopLvl=True, Value=True, ConLike=True,
         WorkFree=True, Expandable=True,
         Guidance=ALWAYS_IF(arity=1,unsat_ok=False,boring_ok=False)
         Tmpl= \ (@ a_ana) (dt_ap3 [Occ=Once] :: a_ana) ->
                 Foo.L @ Z @ a_ana @~ <Z>_N dt_ap3}]
Foo.$WL =
  \ (@ a_ana) (dt_ap3 [Occ=Once] :: a_ana) ->
    Foo.L @ Z @ a_ana @~ <Z>_N dt_ap3

Foo.$WB [InlPrag=INLINE]
  :: forall a_anc n_anb.
     Pair (Tree n_anb a_anc) -> Tree (S n_anb) a_anc
[GblId[DataConWrapper],
 Arity=1,
 Caf=NoCafRefs,
 Str=DmdType <L,U>,
 Unf=Unf{Src=InlineStable, TopLvl=True, Value=True, ConLike=True,
         WorkFree=True, Expandable=True,
         Guidance=ALWAYS_IF(arity=1,unsat_ok=False,boring_ok=False)
         Tmpl= \ (@ a_anc)
                 (@ n_anb)
                 (dt_apb [Occ=Once] :: Pair (Tree n_anb a_anc)) ->
                 Foo.B @ (S n_anb) @ a_anc @ n_anb @~ <S n_anb>_N dt_apb}]
Foo.$WB =
  \ (@ a_anc)
    (@ n_anb)
    (dt_apb [Occ=Once] :: Pair (Tree n_anb a_anc)) ->
    Foo.B @ (S n_anb) @ a_anc @ n_anb @~ <S n_anb>_N dt_apb

Foo.$fFunctorTree_$cfmap
  :: forall a_apW b_apX.
     (a_apW -> b_apX) -> Tree Z a_apW -> Tree Z b_apX
[GblId,
 Arity=2,
 Caf=NoCafRefs,
 Str=DmdType <L,1*C1(U)><S,1*U>,
 Unf=Unf{Src=InlineStable, TopLvl=True, Value=True, ConLike=True,
         WorkFree=True, Expandable=True,
         Guidance=ALWAYS_IF(arity=2,unsat_ok=True,boring_ok=False)
         Tmpl= \ (@ a_azU)
                 (@ b_azV)
                 (f_aon [Occ=Once!] :: a_azU -> b_azV)
                 (ds_dAM [Occ=Once!] :: Tree Z a_azU) ->
                 case ds_dAM of _ [Occ=Dead] { L _ [Occ=Dead] a1_aoo [Occ=Once] ->
                 Foo.L @ Z @ b_azV @~ <Z>_N (f_aon a1_aoo)
                 }}]
Foo.$fFunctorTree_$cfmap =
  \ (@ a_azU)
    (@ b_azV)
    (f_aon :: a_azU -> b_azV)
    (ds_dAM :: Tree Z a_azU) ->
    case ds_dAM of _ [Occ=Dead] { L dt_dAW a1_aoo ->
    Foo.L @ Z @ b_azV @~ <Z>_N (f_aon a1_aoo)
    }

Foo.$fFunctorTree0_$c<$
  :: forall a_az2 b_az3. a_az2 -> Tree Z b_az3 -> Tree Z a_az2
[GblId,
 Arity=2,
 Caf=NoCafRefs,
 Str=DmdType <L,U><S,1*U>,
 Unf=Unf{Src=InlineStable, TopLvl=True, Value=True, ConLike=True,
         WorkFree=True, Expandable=True,
         Guidance=ALWAYS_IF(arity=2,unsat_ok=True,boring_ok=False)
         Tmpl= \ (@ a_aAZ)
                 (@ b_aB0)
                 (eta_aB1 [Occ=Once] :: a_aAZ)
                 (ds_dAM [Occ=Once!] :: Tree Z b_aB0) ->
                 case ds_dAM of _ [Occ=Dead] { L _ [Occ=Dead] _ [Occ=Dead] ->
                 Foo.L @ Z @ a_aAZ @~ <Z>_N eta_aB1
                 }}]
Foo.$fFunctorTree0_$c<$ =
  \ (@ a_aAZ)
    (@ b_aB0)
    (eta_aB1 :: a_aAZ)
    (ds_dAM :: Tree Z b_aB0) ->
    case ds_dAM of _ [Occ=Dead] { L dt_dAW a1_aoo ->
    Foo.L @ Z @ a_aAZ @~ <Z>_N eta_aB1
    }

Foo.$fFunctorTree0 [InlPrag=[ALWAYS] CONLIKE] :: Functor (Tree Z)
[GblId[DFunId],
 Caf=NoCafRefs,
 Str=DmdType m,
 Unf=DFun: \ ->
       GHC.Base.D:Functor TYPE Tree Z
                          Foo.$fFunctorTree_$cfmap
                          Foo.$fFunctorTree0_$c<$]
Foo.$fFunctorTree0 =
  GHC.Base.D:Functor
    @ (Tree Z) Foo.$fFunctorTree_$cfmap Foo.$fFunctorTree0_$c<$

Foo.$fFunctorPair_$cfmap
  :: forall a_apW b_apX. (a_apW -> b_apX) -> Pair a_apW -> Pair b_apX
[GblId,
 Arity=2,
 Caf=NoCafRefs,
 Str=DmdType <L,C(U)><S,1*U(U,U)>m,
 Unf=Unf{Src=InlineStable, TopLvl=True, Value=True, ConLike=True,
         WorkFree=True, Expandable=True,
         Guidance=ALWAYS_IF(arity=2,unsat_ok=True,boring_ok=False)
         Tmpl= \ (@ a_ayV)
                 (@ b_ayW)
                 (f_apF :: a_ayV -> b_ayW)
                 (ds_dAC [Occ=Once!] :: Pair a_ayV) ->
                 case ds_dAC
                 of _ [Occ=Dead] { :# a1_apG [Occ=Once] a2_apH [Occ=Once] ->
                 Foo.:# @ b_ayW (f_apF a1_apG) (f_apF a2_apH)
                 }}]
Foo.$fFunctorPair_$cfmap =
  \ (@ a_ayV)
    (@ b_ayW)
    (f_apF :: a_ayV -> b_ayW)
    (ds_dAC :: Pair a_ayV) ->
    case ds_dAC of _ [Occ=Dead] { :# a1_apG a2_apH ->
    Foo.:# @ b_ayW (f_apF a1_apG) (f_apF a2_apH)
    }

Foo.$fFunctorPair_$c<$
  :: forall a_az2 b_az3. a_az2 -> Pair b_az3 -> Pair a_az2
[GblId,
 Arity=2,
 Caf=NoCafRefs,
 Str=DmdType <L,U><S,1*H>m,
 Unf=Unf{Src=InlineStable, TopLvl=True, Value=True, ConLike=True,
         WorkFree=True, Expandable=True,
         Guidance=ALWAYS_IF(arity=2,unsat_ok=True,boring_ok=False)
         Tmpl= \ (@ a_aAZ)
                 (@ b_aB0)
                 (eta_aB1 :: a_aAZ)
                 (eta1_B1 [Occ=Once!] :: Pair b_aB0) ->
                 case eta1_B1 of _ [Occ=Dead] { :# _ [Occ=Dead] _ [Occ=Dead] ->
                 Foo.:# @ a_aAZ eta_aB1 eta_aB1
                 }}]
Foo.$fFunctorPair_$c<$ =
  \ (@ a_aAZ) (@ b_aB0) (eta_aB1 :: a_aAZ) (eta1_B1 :: Pair b_aB0) ->
    case eta1_B1 of _ [Occ=Dead] { :# a1_apG a2_apH ->
    Foo.:# @ a_aAZ eta_aB1 eta_aB1
    }

Foo.$fFunctorPair [InlPrag=[ALWAYS] CONLIKE] :: Functor Pair
[GblId[DFunId],
 Caf=NoCafRefs,
 Str=DmdType m,
 Unf=DFun: \ ->
       GHC.Base.D:Functor TYPE Pair
                          Foo.$fFunctorPair_$cfmap
                          Foo.$fFunctorPair_$c<$]
Foo.$fFunctorPair =
  GHC.Base.D:Functor
    @ Pair Foo.$fFunctorPair_$cfmap Foo.$fFunctorPair_$c<$

Foo.$fFunctorTree_$s$cfmap
  :: forall a_apW b_apX.
     (a_apW -> b_apX) -> Tree (S Z) a_apW -> Tree (S Z) b_apX
[GblId,
 Arity=2,
 Caf=NoCafRefs,
 Str=DmdType <L,C(U)><S,1*U>,
 Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
         WorkFree=True, Expandable=True, Guidance=IF_ARGS [0 20] 100 20}]
Foo.$fFunctorTree_$s$cfmap =
  \ (@ a_azg)
    (@ b_azh)
    (f_aol :: a_azg -> b_azh)
    (ds_dAE :: Tree (S Z) a_azg) ->
    case ds_dAE of _ [Occ=Dead] { B @ n_azj dt_dAQ ts_aom ->
    Foo.B
      @ (S Z)
      @ b_azh
      @ Z
      @~ <S Z>_N
      (case ts_aom
            `cast` ((Pair (Tree (Nth:0 (Sym dt_dAQ)) <a_azg>_R)_R)_R
                    :: Pair (Tree n_azj a_azg) ~R# Pair (Tree Z a_azg))
       of _ [Occ=Dead] { :# a1_apG a2_apH ->
       Foo.:#
         @ (Tree Z b_azh)
         (Foo.$fFunctorTree_$cfmap @ a_azg @ b_azh f_aol a1_apG)
         (Foo.$fFunctorTree_$cfmap @ a_azg @ b_azh f_aol a2_apH)
       })
    }

Foo.$fFunctorTree_$cfmap1
  :: forall n_azb.
     Functor (Tree n_azb) =>
     forall a_apW b_apX.
     (a_apW -> b_apX) -> Tree (S n_azb) a_apW -> Tree (S n_azb) b_apX
[GblId,
 Arity=3,
 Caf=NoCafRefs,
 Str=DmdType <L,1*U(1*C1(U),A)><L,U><S,1*U>,
 Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
         WorkFree=True, Expandable=True, Guidance=IF_ARGS [30 0 20] 120 20}]
Foo.$fFunctorTree_$cfmap1 =
  \ (@ n_azb)
    ($dFunctor_azc :: Functor (Tree n_azb))
    (@ a_azg)
    (@ b_azh)
    (f_aol :: a_azg -> b_azh)
    (ds_dAE :: Tree (S n_azb) a_azg) ->
    case ds_dAE of _ [Occ=Dead] { B @ n1_azj dt_dAQ ts_aom ->
    Foo.B
      @ (S n_azb)
      @ b_azh
      @ n_azb
      @~ <S n_azb>_N
      (case ts_aom
            `cast` ((Pair (Tree (Nth:0 (Sym dt_dAQ)) <a_azg>_R)_R)_R
                    :: Pair (Tree n1_azj a_azg) ~R# Pair (Tree n_azb a_azg))
       of _ [Occ=Dead] { :# a1_apG a2_apH ->
       let {
         f1_apF [Dmd=<L,C(U)>] :: Tree n_azb a_azg -> Tree n_azb b_azh
         [LclId, Str=DmdType]
         f1_apF =
           fmap @ (Tree n_azb) $dFunctor_azc @ a_azg @ b_azh f_aol } in
       Foo.:# @ (Tree n_azb b_azh) (f1_apF a1_apG) (f1_apF a2_apH)
       })
    }

Foo.$fFunctorTree_$c<$
  :: forall n_azb.
     Functor (Tree n_azb) =>
     forall a_az2 b_az3.
     a_az2 -> Tree (S n_azb) b_az3 -> Tree (S n_azb) a_az2
[GblId,
 Arity=3,
 Caf=NoCafRefs,
 Str=DmdType <L,1*U(1*C1(U),A)><L,U><S,1*U>,
 Unf=Unf{Src=InlineStable, TopLvl=True, Value=True, ConLike=True,
         WorkFree=True, Expandable=True,
         Guidance=ALWAYS_IF(arity=3,unsat_ok=True,boring_ok=False)
         Tmpl= \ (@ n_azb)
                 ($dFunctor_azc [Occ=Once] :: Functor (Tree n_azb))
                 (@ a_aAZ)
                 (@ b_aB0)
                 (eta_aB1 [Occ=OnceL] :: a_aAZ)
                 (eta1_B1 [Occ=Once] :: Tree (S n_azb) b_aB0) ->
                 Foo.$fFunctorTree_$cfmap1
                   @ n_azb
                   $dFunctor_azc
                   @ b_aB0
                   @ a_aAZ
                   (\ _ [Occ=Dead] -> eta_aB1)
                   eta1_B1}]
Foo.$fFunctorTree_$c<$ =
  \ (@ n_azb)
    ($dFunctor_azc :: Functor (Tree n_azb))
    (@ a_aAZ)
    (@ b_aB0)
    (eta_aB1 :: a_aAZ)
    (eta1_B1 :: Tree (S n_azb) b_aB0) ->
    Foo.$fFunctorTree_$cfmap1
      @ n_azb
      $dFunctor_azc
      @ b_aB0
      @ a_aAZ
      (\ _ [Occ=Dead] -> eta_aB1)
      eta1_B1

Foo.$fFunctorTree [InlPrag=[ALWAYS] CONLIKE]
  :: forall n_apq. Functor (Tree n_apq) => Functor (Tree (S n_apq))
[GblId[DFunId],
 Arity=1,
 Caf=NoCafRefs,
 Str=DmdType <L,U(C(U),A)>m,
 Unf=DFun: \ (@ n_azb) ($dFunctor_azc :: Functor (Tree n_azb)) ->
       GHC.Base.D:Functor TYPE Tree (S n_azb)
                          Foo.$fFunctorTree_$cfmap1 @ n_azb $dFunctor_azc
                          Foo.$fFunctorTree_$c<$ @ n_azb $dFunctor_azc]
Foo.$fFunctorTree =
  \ (@ n_azb) ($dFunctor_azc :: Functor (Tree n_azb)) ->
    GHC.Base.D:Functor
      @ (Tree (S n_azb))
      (Foo.$fFunctorTree_$cfmap1 @ n_azb $dFunctor_azc)
      (Foo.$fFunctorTree_$c<$ @ n_azb $dFunctor_azc)

Foo.foo1 :: Int -> Int
[GblId,
 Arity=1,
 Caf=NoCafRefs,
 Str=DmdType <S,1*U(U)>m,
 Unf=Unf{Src=InlineStable, TopLvl=True, Value=True, ConLike=True,
         WorkFree=True, Expandable=True,
         Guidance=ALWAYS_IF(arity=1,unsat_ok=True,boring_ok=False)
         Tmpl= \ (ds_dAA [Occ=Once!] :: Int) ->
                 case ds_dAA of _ [Occ=Dead] { GHC.Types.I# x_aBr [Occ=Once] ->
                 GHC.Types.I# (GHC.Prim.+# x_aBr 1)
                 }}]
Foo.foo1 =
  \ (ds_dAA :: Int) ->
    case ds_dAA of _ [Occ=Dead] { GHC.Types.I# x_aBr ->
    GHC.Types.I# (GHC.Prim.+# x_aBr 1)
    }

Foo.foo_f8 :: Tree (S (S Z)) Int -> Tree (S (S Z)) Int
[GblId,
 Arity=1,
 Caf=NoCafRefs,
 Str=DmdType <S,1*U>,
 Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
         WorkFree=True, Expandable=True, Guidance=IF_ARGS [20] 100 20}]
Foo.foo_f8 =
  \ (ds_XDj :: Tree (S (S Z)) Int) ->
    case ds_XDj of _ [Occ=Dead] { B @ n_XC0 dt_XDy ts_Xr5 ->
    Foo.B
      @ (S (S Z))
      @ Int
      @ (S Z)
      @~ <S (S Z)>_N
      (case ts_Xr5
            `cast` ((Pair (Tree (Nth:0 (Sym dt_XDy)) <Int>_R)_R)_R
                    :: Pair (Tree n_XC0 Int) ~R# Pair (Tree (S Z) Int))
       of _ [Occ=Dead] { :# a1_Xso a2_Xsq ->
       Foo.:#
         @ (Tree (S Z) Int)
         (Foo.$fFunctorTree_$s$cfmap @ Int @ Int Foo.foo1 a1_Xso)
         (Foo.$fFunctorTree_$s$cfmap @ Int @ Int Foo.foo1 a2_Xsq)
       })
    }

Foo.foo_f7 :: Tree (S (S (S Z))) Int -> Tree (S (S (S Z))) Int
[GblId,
 Arity=1,
 Caf=NoCafRefs,
 Str=DmdType <S,1*U>,
 Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
         WorkFree=True, Expandable=True, Guidance=IF_ARGS [20] 80 20}]
Foo.foo_f7 =
  \ (ds_XD9 :: Tree (S (S (S Z))) Int) ->
    case ds_XD9 of _ [Occ=Dead] { B @ n_XBQ dt_XDo ts_Xtm ->
    Foo.B
      @ (S (S (S Z)))
      @ Int
      @ (S (S Z))
      @~ <S (S (S Z))>_N
      (case ts_Xtm
            `cast` ((Pair (Tree (Nth:0 (Sym dt_XDo)) <Int>_R)_R)_R
                    :: Pair (Tree n_XBQ Int) ~R# Pair (Tree (S (S Z)) Int))
       of _ [Occ=Dead] { :# a1_Xsb a2_Xsd ->
       Foo.:#
         @ (Tree (S (S Z)) Int) (Foo.foo_f8 a1_Xsb) (Foo.foo_f8 a2_Xsd)
       })
    }

Foo.foo_f6
  :: Tree (S (S (S (S Z)))) Int -> Tree (S (S (S (S Z)))) Int
[GblId,
 Arity=1,
 Caf=NoCafRefs,
 Str=DmdType <S,1*U>,
 Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
         WorkFree=True, Expandable=True, Guidance=IF_ARGS [20] 80 20}]
Foo.foo_f6 =
  \ (ds_XCZ :: Tree (S (S (S (S Z)))) Int) ->
    case ds_XCZ of _ [Occ=Dead] { B @ n_XBG dt_XDe ts_XqL ->
    Foo.B
      @ (S (S (S (S Z))))
      @ Int
      @ (S (S (S Z)))
      @~ <S (S (S (S Z)))>_N
      (case ts_XqL
            `cast` ((Pair (Tree (Nth:0 (Sym dt_XDe)) <Int>_R)_R)_R
                    :: Pair (Tree n_XBG Int) ~R# Pair (Tree (S (S (S Z))) Int))
       of _ [Occ=Dead] { :# a1_XrY a2_Xs0 ->
       Foo.:#
         @ (Tree (S (S (S Z))) Int) (Foo.foo_f7 a1_XrY) (Foo.foo_f7 a2_Xs0)
       })
    }

Foo.foo_f5
  :: Tree (S (S (S (S (S Z))))) Int -> Tree (S (S (S (S (S Z))))) Int
[GblId,
 Arity=1,
 Caf=NoCafRefs,
 Str=DmdType <S,1*U>,
 Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
         WorkFree=True, Expandable=True, Guidance=IF_ARGS [20] 80 20}]
Foo.foo_f5 =
  \ (ds_XCP :: Tree (S (S (S (S (S Z))))) Int) ->
    case ds_XCP of _ [Occ=Dead] { B @ n_XBw dt_XD4 ts_XqB ->
    Foo.B
      @ (S (S (S (S (S Z)))))
      @ Int
      @ (S (S (S (S Z))))
      @~ <S (S (S (S (S Z))))>_N
      (case ts_XqB
            `cast` ((Pair (Tree (Nth:0 (Sym dt_XD4)) <Int>_R)_R)_R
                    :: Pair (Tree n_XBw Int) ~R# Pair (Tree (S (S (S (S Z)))) Int))
       of _ [Occ=Dead] { :# a1_XrL a2_XtT ->
       Foo.:#
         @ (Tree (S (S (S (S Z)))) Int)
         (Foo.foo_f6 a1_XrL)
         (Foo.foo_f6 a2_XtT)
       })
    }

Foo.foo_f4
  :: Tree (S (S (S (S (S (S Z)))))) Int
     -> Tree (S (S (S (S (S (S Z)))))) Int
[GblId,
 Arity=1,
 Caf=NoCafRefs,
 Str=DmdType <S,1*U>,
 Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
         WorkFree=True, Expandable=True, Guidance=IF_ARGS [20] 80 20}]
Foo.foo_f4 =
  \ (ds_XCF :: Tree (S (S (S (S (S (S Z)))))) Int) ->
    case ds_XCF of _ [Occ=Dead] { B @ n_XBm dt_XCU ts_Xqr ->
    Foo.B
      @ (S (S (S (S (S (S Z))))))
      @ Int
      @ (S (S (S (S (S Z)))))
      @~ <S (S (S (S (S (S Z)))))>_N
      (case ts_Xqr
            `cast` ((Pair (Tree (Nth:0 (Sym dt_XCU)) <Int>_R)_R)_R
                    :: Pair (Tree n_XBm Int) ~R# Pair (Tree (S (S (S (S (S Z))))) Int))
       of _ [Occ=Dead] { :# a1_Xry a2_XrA ->
       Foo.:#
         @ (Tree (S (S (S (S (S Z))))) Int)
         (Foo.foo_f5 a1_Xry)
         (Foo.foo_f5 a2_XrA)
       })
    }

Foo.foo_f3
  :: Tree (S (S (S (S (S (S (S Z))))))) Int
     -> Tree (S (S (S (S (S (S (S Z))))))) Int
[GblId,
 Arity=1,
 Caf=NoCafRefs,
 Str=DmdType <S,1*U>,
 Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
         WorkFree=True, Expandable=True, Guidance=IF_ARGS [20] 80 20}]
Foo.foo_f3 =
  \ (ds_XCv :: Tree (S (S (S (S (S (S (S Z))))))) Int) ->
    case ds_XCv of _ [Occ=Dead] { B @ n_XBc dt_XCK ts_Xqh ->
    Foo.B
      @ (S (S (S (S (S (S (S Z)))))))
      @ Int
      @ (S (S (S (S (S (S Z))))))
      @~ <S (S (S (S (S (S (S Z))))))>_N
      (case ts_Xqh
            `cast` ((Pair (Tree (Nth:0 (Sym dt_XCK)) <Int>_R)_R)_R
                    :: Pair (Tree n_XBc Int)
                       ~R# Pair (Tree (S (S (S (S (S (S Z)))))) Int))
       of _ [Occ=Dead] { :# a1_Xrl a2_Xrn ->
       Foo.:#
         @ (Tree (S (S (S (S (S (S Z)))))) Int)
         (Foo.foo_f4 a1_Xrl)
         (Foo.foo_f4 a2_Xrn)
       })
    }

Foo.foo_f2
  :: Tree (S (S (S (S (S (S (S (S Z)))))))) Int
     -> Tree (S (S (S (S (S (S (S (S Z)))))))) Int
[GblId,
 Arity=1,
 Caf=NoCafRefs,
 Str=DmdType <S,1*U>,
 Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
         WorkFree=True, Expandable=True, Guidance=IF_ARGS [20] 80 20}]
Foo.foo_f2 =
  \ (ds_XCl :: Tree (S (S (S (S (S (S (S (S Z)))))))) Int) ->
    case ds_XCl of _ [Occ=Dead] { B @ n_XB2 dt_XCA ts_Xq7 ->
    Foo.B
      @ (S (S (S (S (S (S (S (S Z))))))))
      @ Int
      @ (S (S (S (S (S (S (S Z)))))))
      @~ <S (S (S (S (S (S (S (S Z)))))))>_N
      (case ts_Xq7
            `cast` ((Pair (Tree (Nth:0 (Sym dt_XCA)) <Int>_R)_R)_R
                    :: Pair (Tree n_XB2 Int)
                       ~R# Pair (Tree (S (S (S (S (S (S (S Z))))))) Int))
       of _ [Occ=Dead] { :# a1_Xr8 a2_Xra ->
       Foo.:#
         @ (Tree (S (S (S (S (S (S (S Z))))))) Int)
         (Foo.foo_f3 a1_Xr8)
         (Foo.foo_f3 a2_Xra)
       })
    }

Foo.foo_f1
  :: Tree (S (S (S (S (S (S (S (S (S Z))))))))) Int
     -> Tree (S (S (S (S (S (S (S (S (S Z))))))))) Int
[GblId,
 Arity=1,
 Caf=NoCafRefs,
 Str=DmdType <S,1*U>,
 Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
         WorkFree=True, Expandable=True, Guidance=IF_ARGS [20] 80 20}]
Foo.foo_f1 =
  \ (ds_XCb :: Tree (S (S (S (S (S (S (S (S (S Z))))))))) Int) ->
    case ds_XCb of _ [Occ=Dead] { B @ n_XAS dt_XCq ts_XpX ->
    Foo.B
      @ (S (S (S (S (S (S (S (S (S Z)))))))))
      @ Int
      @ (S (S (S (S (S (S (S (S Z))))))))
      @~ <S (S (S (S (S (S (S (S (S Z))))))))>_N
      (case ts_XpX
            `cast` ((Pair (Tree (Nth:0 (Sym dt_XCq)) <Int>_R)_R)_R
                    :: Pair (Tree n_XAS Int)
                       ~R# Pair (Tree (S (S (S (S (S (S (S (S Z)))))))) Int))
       of _ [Occ=Dead] { :# a1_XqV a2_XqX ->
       Foo.:#
         @ (Tree (S (S (S (S (S (S (S (S Z)))))))) Int)
         (Foo.foo_f2 a1_XqV)
         (Foo.foo_f2 a2_XqX)
       })
    }

Foo.foo_f
  :: Tree (S (S (S (S (S (S (S (S (S (S Z)))))))))) Int
     -> Tree (S (S (S (S (S (S (S (S (S (S Z)))))))))) Int
[GblId,
 Arity=1,
 Caf=NoCafRefs,
 Str=DmdType <S,1*U>,
 Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
         WorkFree=True, Expandable=True, Guidance=IF_ARGS [20] 80 20}]
Foo.foo_f =
  \ (ds_XC1 :: Tree (S (S (S (S (S (S (S (S (S (S Z)))))))))) Int) ->
    case ds_XC1 of _ [Occ=Dead] { B @ n_XAI dt_XCg ts_XpN ->
    Foo.B
      @ (S (S (S (S (S (S (S (S (S (S Z))))))))))
      @ Int
      @ (S (S (S (S (S (S (S (S (S Z)))))))))
      @~ <S (S (S (S (S (S (S (S (S (S Z)))))))))>_N
      (case ts_XpN
            `cast` ((Pair (Tree (Nth:0 (Sym dt_XCg)) <Int>_R)_R)_R
                    :: Pair (Tree n_XAI Int)
                       ~R# Pair (Tree (S (S (S (S (S (S (S (S (S Z))))))))) Int))
       of _ [Occ=Dead] { :# a1_XqI a2_XqK ->
       Foo.:#
         @ (Tree (S (S (S (S (S (S (S (S (S Z))))))))) Int)
         (Foo.foo_f1 a1_XqI)
         (Foo.foo_f1 a2_XqK)
       })
    }

foo
  :: Unop (Tree (S (S (S (S (S (S (S (S (S (S (S Z))))))))))) Int)
[GblId,
 Arity=1,
 Caf=NoCafRefs,
 Str=DmdType <S,1*U>,
 Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
         WorkFree=True, Expandable=True, Guidance=IF_ARGS [20] 80 20}]
foo =
  \ (ds_dAE
       :: Tree (S (S (S (S (S (S (S (S (S (S (S Z))))))))))) Int) ->
    case ds_dAE of _ [Occ=Dead] { B @ n_azj dt_dAQ ts_aom ->
    Foo.B
      @ (S (S (S (S (S (S (S (S (S (S (S Z)))))))))))
      @ Int
      @ (S (S (S (S (S (S (S (S (S (S Z))))))))))
      @~ <S (S (S (S (S (S (S (S (S (S (S Z))))))))))>_N
      (case ts_aom
            `cast` ((Pair (Tree (Nth:0 (Sym dt_dAQ)) <Int>_R)_R)_R
                    :: Pair (Tree n_azj Int)
                       ~R# Pair (Tree (S (S (S (S (S (S (S (S (S (S Z)))))))))) Int))
       of _ [Occ=Dead] { :# a1_apG a2_apH ->
       Foo.:#
         @ (Tree (S (S (S (S (S (S (S (S (S (S Z)))))))))) Int)
         (Foo.foo_f a1_apG)
         (Foo.foo_f a2_apH)
       })
    }


------ Local rules for imported ids --------
"SPEC $cfmap @ Z" [ALWAYS]
    forall ($dFunctor_sBY :: Functor (Tree Z)).
      Foo.$fFunctorTree_$cfmap1 @ Z $dFunctor_sBY
      = Foo.$fFunctorTree_$s$cfmap