\(input :: inp) ->
  let !(#
         init,
         readMore,
         readNext
         #) =
          let _ = "cursorOf"
           in let next
                    ( t@( Data.Text.Internal.Text
                            arr
                            off
                            unconsumed
                          )
                      ) =
                      let !( Data.Text.Unsafe.Iter
                               c
                               d
                             ) = Data.Text.Unsafe.iter t 0
                       in (#
                            c,
                            Data.Text.Internal.Text arr (off GHC.Num.+ d) (unconsumed GHC.Num.- d)
                          #)
                  more
                    ( Data.Text.Internal.Text
                        _
                        _
                        unconsumed
                      ) = unconsumed GHC.Classes.> 0
               in (# input, more, next #)
      finalRet = \_farInp _farExp v _inp -> Symantic.Parser.Machine.Generate.returnST GHC.Base.$ Data.Either.Right v
      finalRaise ::
        forall st b.
        Symantic.Parser.Machine.Generate.OnException
          st
          inp
          b = \(!exn) _failInp (!farInp) (!farExp) ->
          Symantic.Parser.Machine.Generate.returnST GHC.Base.$
            Data.Either.Left
              Symantic.Parser.Machine.Generate.ParsingError
                { Symantic.Parser.Machine.Generate.parsingErrorOffset = Symantic.Parser.Machine.Input.offset farInp,
                  Symantic.Parser.Machine.Generate.parsingErrorException = exn,
                  Symantic.Parser.Machine.Generate.parsingErrorUnexpected =
                    if readMore farInp
                      then
                        GHC.Maybe.Just
                          ( let (#
                                  c,
                                  _
                                  #) = readNext farInp
                             in c
                          )
                      else GHC.Maybe.Nothing,
                  Symantic.Parser.Machine.Generate.parsingErrorExpecting =
                    let ( minHoriz,
                          res
                          ) =
                            Data.Set.Internal.foldr
                              ( \f
                                 ( minH,
                                   acc
                                   ) -> case Symantic.Parser.Grammar.Combinators.unSomeFailure f of
                                    GHC.Maybe.Just (Symantic.Parser.Grammar.Combinators.FailureHorizon h :: Symantic.Parser.Grammar.Combinators.Failure (Symantic.Parser.Grammar.Combinators.CombSatisfiable (Symantic.Parser.Machine.Input.InputToken inp)))
                                      | GHC.Maybe.Just old <- minH ->
                                        ( GHC.Maybe.Just (GHC.Classes.min old h),
                                          acc
                                        )
                                      | GHC.Base.otherwise ->
                                        ( GHC.Maybe.Just h,
                                          acc
                                        )
                                    _ ->
                                      ( minH,
                                        f GHC.Types.: acc
                                      )
                              )
                              ( GHC.Maybe.Nothing,
                                GHC.Types . []
                              )
                              farExp
                     in Data.Set.Internal.fromList GHC.Base.$
                          ( case minHoriz of
                              GHC.Maybe.Just h -> Symantic.Parser.Grammar.Combinators.SomeFailure (Symantic.Parser.Grammar.Combinators.FailureHorizon @(Symantic.Parser.Machine.Input.InputToken inp) h) GHC.Types.: res
                              GHC.Maybe.Nothing -> res
                          )
                }
   in GHC.ST.runST
        ( let inputToken = Data.Proxy.Proxy :: Data.Proxy.Proxy (Symantic.Parser.Machine.Input.InputToken inp)
           in let inp = init
               in let readFail = finalRaise
                   in let _ = "checkHorizon.newCheck: checkedHorizon=0 minHoriz=3"
                       in if readMore (Symantic.Parser.Machine.Input.shiftRightText 2 inp)
                            then
                              let
                               in let _ = "pushValue"
                                   in let _ = "catch ExceptionFailure checkedHorizon=3"
                                       in let onException =
                                                let _ = "onException"
                                                 in \(!_exn) (!failInp) (!farInp) (!farExp) ->
                                                      let _ = "loadInput checkedHorizon=3"
                                                       in let _ = "checkHorizon.oldCheck: checkedHorizon=3"
                                                           in finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp
                                           in let _ = "pushValue"
                                               in let _ = "comment: satisfy ((GHC.Classes.==) 'a')"
                                                   in let _ = "checkHorizon.oldCheck: checkedHorizon=3"
                                                       in let _ = "checkToken"
                                                           in let !(#
                                                                     c,
                                                                     cs
                                                                     #) = readNext inp
                                                               in if (GHC.Classes.==) 'a' c
                                                                    then
                                                                      let _ = "lift2Value checkedHorizon=2"
                                                                       in let _ = "comment: satisfy ((GHC.Classes.==) 'b')"
                                                                           in let _ = "checkHorizon.oldCheck: checkedHorizon=2"
                                                                               in let _ = "checkToken"
                                                                                   in let !(#
                                                                                             c,
                                                                                             cs
                                                                                             #) = readNext cs
                                                                                       in if (GHC.Classes.==) 'b' c
                                                                                            then
                                                                                              let _ = "lift2Value checkedHorizon=1"
                                                                                               in let _ = "comment: satisfy ((GHC.Classes.==) 'c')"
                                                                                                   in let _ = "checkHorizon.oldCheck: checkedHorizon=1"
                                                                                                       in let _ = "checkToken"
                                                                                                           in let !(#
                                                                                                                     c,
                                                                                                                     cs
                                                                                                                     #) = readNext cs
                                                                                                               in if (GHC.Classes.==) 'c' c
                                                                                                                    then
                                                                                                                      let _ = "lift2Value checkedHorizon=0"
                                                                                                                       in let _ = "commit"
                                                                                                                           in let _ = "lift2Value checkedHorizon=0"
                                                                                                                               in let _ = "resume"
                                                                                                                                   in finalRet
                                                                                                                                        init
                                                                                                                                        Data.Set.Internal.empty
                                                                                                                                        ( let _ = "resume.genCode"
                                                                                                                                           in GHC.Show.show ((GHC.Types.:) 'a' ((GHC.Types.:) 'b' ((GHC.Types.:) 'c' GHC.Types . [])))
                                                                                                                                        )
                                                                                                                                        cs
                                                                                                                    else
                                                                                                                      let _ = "checkToken.fail"
                                                                                                                       in let failExp =
                                                                                                                                Data.Set.Internal.Bin
                                                                                                                                  1
                                                                                                                                  ( Symantic.Parser.Grammar.Combinators.SomeFailure
                                                                                                                                      ( case inputToken of
                                                                                                                                          (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'c'
                                                                                                                                      )
                                                                                                                                  )
                                                                                                                                  Data.Set.Internal.Tip
                                                                                                                                  Data.Set.Internal.Tip
                                                                                                                           in let (#
                                                                                                                                    farInp,
                                                                                                                                    farExp
                                                                                                                                    #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init cs of
                                                                                                                                      GHC.Types.LT ->
                                                                                                                                        (#
                                                                                                                                          cs,
                                                                                                                                          failExp
                                                                                                                                        #)
                                                                                                                                      GHC.Types.EQ ->
                                                                                                                                        (#
                                                                                                                                          init,
                                                                                                                                          failExp GHC.Base.<> Data.Set.Internal.empty
                                                                                                                                        #)
                                                                                                                                      GHC.Types.GT ->
                                                                                                                                        (#
                                                                                                                                          init,
                                                                                                                                          Data.Set.Internal.empty
                                                                                                                                        #)
                                                                                                                               in onException Symantic.Parser.Grammar.Combinators.ExceptionFailure cs farInp farExp
                                                                                            else
                                                                                              let _ = "checkToken.fail"
                                                                                               in let failExp =
                                                                                                        Data.Set.Internal.Bin
                                                                                                          1
                                                                                                          ( Symantic.Parser.Grammar.Combinators.SomeFailure
                                                                                                              ( case inputToken of
                                                                                                                  (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'b'
                                                                                                              )
                                                                                                          )
                                                                                                          Data.Set.Internal.Tip
                                                                                                          Data.Set.Internal.Tip
                                                                                                   in let (#
                                                                                                            farInp,
                                                                                                            farExp
                                                                                                            #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init cs of
                                                                                                              GHC.Types.LT ->
                                                                                                                (#
                                                                                                                  cs,
                                                                                                                  failExp
                                                                                                                #)
                                                                                                              GHC.Types.EQ ->
                                                                                                                (#
                                                                                                                  init,
                                                                                                                  failExp GHC.Base.<> Data.Set.Internal.empty
                                                                                                                #)
                                                                                                              GHC.Types.GT ->
                                                                                                                (#
                                                                                                                  init,
                                                                                                                  Data.Set.Internal.empty
                                                                                                                #)
                                                                                                       in onException Symantic.Parser.Grammar.Combinators.ExceptionFailure cs farInp farExp
                                                                    else
                                                                      let _ = "checkToken.fail"
                                                                       in let failExp =
                                                                                Data.Set.Internal.Bin
                                                                                  1
                                                                                  ( Symantic.Parser.Grammar.Combinators.SomeFailure
                                                                                      ( case inputToken of
                                                                                          (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'a'
                                                                                      )
                                                                                  )
                                                                                  Data.Set.Internal.Tip
                                                                                  Data.Set.Internal.Tip
                                                                           in let (#
                                                                                    farInp,
                                                                                    farExp
                                                                                    #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of
                                                                                      GHC.Types.LT ->
                                                                                        (#
                                                                                          inp,
                                                                                          failExp
                                                                                        #)
                                                                                      GHC.Types.EQ ->
                                                                                        (#
                                                                                          init,
                                                                                          failExp GHC.Base.<> Data.Set.Internal.empty
                                                                                        #)
                                                                                      GHC.Types.GT ->
                                                                                        (#
                                                                                          init,
                                                                                          Data.Set.Internal.empty
                                                                                        #)
                                                                               in onException Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp
                            else
                              let _ = "checkHorizon.newCheck.fail"
                               in let failExp =
                                        Data.Set.Internal.Bin
                                          1
                                          ( Symantic.Parser.Grammar.Combinators.SomeFailure
                                              ( case inputToken of
                                                  (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 3
                                              )
                                          )
                                          Data.Set.Internal.Tip
                                          Data.Set.Internal.Tip
                                   in let (#
                                            farInp,
                                            farExp
                                            #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of
                                              GHC.Types.LT ->
                                                (#
                                                  inp,
                                                  failExp
                                                #)
                                              GHC.Types.EQ ->
                                                (#
                                                  init,
                                                  failExp GHC.Base.<> Data.Set.Internal.empty
                                                #)
                                              GHC.Types.GT ->
                                                (#
                                                  init,
                                                  Data.Set.Internal.empty
                                                #)
                                       in finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp
        )