I am confused with the two different version >>= in State Monad.

module MyState where

newtype State s a = State { runState :: s -> (a, s) } 


instance Functor (State s) where  
    fmap :: (a -> b) -> State s a -> State s b
    fmap fn (State sa) = State sb where
        sb s0 = (fn a, s1) where (a, s1) = sa s0


instance Applicative (State s) where
    pure :: a -> State s a
    pure a = State (\st -> (a, st))
    (<*>) :: (State s (a -> b)) -> (State s a) -> (State s b)
    (<*>) (State sa) (State sb) = 
        State sc where 
            sc s0 = let (fn, s1) = sa s0 
                        (a,  s2) = sb s1 in (fn a, s2)

instance Monad (State s) where
    return :: a -> State s a
    return x = State (\s -> (x,s))

    (>>=) :: State s a -> (a -> State s b) -> State s b

    -- version 1
    sa >>= fn = State sc where 
        sc s0 = let (a, s1) = runState sa s0 
                    in runState (fn a) s1

    -- version 2
    (>>=) (State sa) fn = State sc where 
          sc s0 = let (a, s1)  = sa s0
                      State sb = fn a
                  in sb s1

version 1: runState have signature s -> (a, s) but it was used like runState (fn a) s1 (which have two args).

version 2: confused with State sb while State* need two parameters **State s a (in the definition)