Why are we slower than mtl? about fused-effects HOT 7 OPEN

import qualified Control.Carrier.State.Strict as F
import qualified Control.Monad.Identity       as M
import qualified Control.Monad.State.Strict   as M

programFused :: F.Has (F.State Int) sig m => m Int
programFused = do
  x <- F.get @Int
  if x == 0
    then pure x
    else do
      F.put (x - 1)
      programFused
{-# NOINLINE programFused #-}

countdownFused :: Int -> (Int, Int)
countdownFused n = F.run $ F.runState n programFused

programMtl :: M.MonadState Int m => m Int
programMtl = do
  x <- M.get
  if x == 0
    then pure x
    else do
      M.put (x - 1)
      programMtl
{-# NOINLINE programMtl #-}

countdownMtl :: Int -> (Int, Int)
countdownMtl n = M.runState programMtl n

programMtl
  = \ (@(m :: Type -> Type))
      (apDict :: Applicative m)
      ((>>=) :: forall a b. m a -> (a -> m b) -> m b)
      ((>>) :: forall a b. m a -> m b -> m b)
      (get :: m Int)
      (put :: Int -> m ()) ->
      let {
        recurse :: m Int
        recurse = programMtl dict (>>=) (>>) get put } in
        get >>=
        \ (x :: Int) ->
           case x of wild { I# x1 ->
           case x1 of wild1 {
             __DEFAULT -> put (I# (-# wild1 1#)) >> recurse;
             0# -> pure apDict wild
           }
           }

programFused
  = \ (@(sig :: (Type -> Type) -> Type -> Type))
      (@(m :: Type -> Type))
      (memDict :: Members (State Int) sig)
      (apDict :: Applicative m)
      ((>>=) :: forall a b. m a -> (a -> m b) -> m b)
      ((>>) :: forall a b. m a -> m b -> m b)
      (alg
         :: forall (ctx :: Type -> Type) (n :: Type -> Type) a.
            Functor ctx =>
            Handler ctx n m -> sig n a -> ctx () -> m (ctx a)) ->
      let {
        recurse :: m Int
        recurse = programFused memDict apDict (>>=) (>>) alg } in
      let {
        monadDict :: Monad m
        monadDict = C:Monad apDict (>>=) (>>) } in
      let {
        algDict :: Algebra sig m
        algDict = C:Algebra monadDict alg } in
      let {
        hasDict :: (Member (State Int) sig, Algebra sig m)
        hasDict = (memDict, algDict) } in
      get hasDict >>=
        \ (x :: Int) ->
           case x of wild { I# x1 ->
           case x1 of wild1 {
             __DEFAULT ->
               put hasDict (I# (-# wild1 1#)) >> recurse;
             0# -> pure apDict wild
           }
           }

countdownMtl
  = programMtl
        apStateT
        monadStateT_>>=
        monadStateT_>>
        getStateT
        putStateT

countdownFused
  = programFused
      injStateC
      apStateC
      monadStateC_>>=
      monadStateC_>>
      algStateC

getStateT = \ (eta :: Int) -> (eta, eta)
putStateT = \ (s1 :: Int) _ -> ((), s1)

injStateC
  = \ (@(m :: Type -> Type)) (@a) (op :: State Int m a) -> L op

algStateC
  = \ (@s)
      (@(ctx :: Type -> Type))
      (@(n :: Type -> Type))
      (@a)
      (functorCtxDict :: Functor ctx)
      (handle :: Handler ctx n (StateC s Identity))
      (sig :: (:+:) (State s) (Lift Identity) n a)
      (ctx :: ctx ()) ->
      let {
        functorSCtxDict :: Functor (Compose ((,) s) ctx)
        functorSCtxDict = functorComposeDict functor(,)Dict functorCtxDict } in
      let {
        thread
          :: forall {x}.
             Compose ((,) s) ctx (n x) -> Identity (Compose ((,) s) ctx x)
        thread
          = \ (@x) (x1 :: Compose ((,) s) ctx (n x)) ->
              case x1 of { (x2, y) -> handle y x2 } } in
      (\ (s :: s) ->
         case sig of {
           L stateOp ->
             case stateOp of {
               Get co -> (s, <$ functorCtxDict s ctx);
               Put co s1 -> (s1, ctx)
             };
           R other ->
             case other of { LiftWith with ->
             (with functorSCtxDict thread ((s, ctx) ))
             }
         })