\(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 #)
   in let finalRet = \_farInp _farExp v _inp -> Data.Either.Right v
       in let finalRaise ::
                forall b.
                Symantic.Parser.Machine.Generate.Catcher
                  inp
                  b = \_failInp (!farInp) (!farExp) ->
                  Data.Either.Left
                    Symantic.Parser.Machine.Generate.ParsingErrorStandard
                      { Symantic.Parser.Machine.Generate.parsingErrorOffset = Symantic.Parser.Machine.Input.offset farInp,
                        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 = Data.Set.Internal.fromList farExp
                      }
           in let
               in let _ = "catchException lbl=fail"
                   in let catchHandler (!failInp) (!farInp) (!farExp) =
                            let _ = "catchException.ko lbl=fail"
                             in let (#
                                      farInp,
                                      farExp
                                      #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp init of
                                        GHC.Types.LT ->
                                          (#
                                            init,
                                            []
                                          #)
                                        GHC.Types.EQ ->
                                          (#
                                            farInp,
                                            farExp GHC.Base.<> []
                                          #)
                                        GHC.Types.GT ->
                                          (#
                                            farInp,
                                            farExp
                                          #)
                                 in finalRaise init farInp farExp
                       in let readFail = catchHandler
                           in if readMore (Symantic.Parser.Machine.Input.shiftRightText 2 init)
                                then
                                  let !(# c, cs #) = readNext init
                                   in if ('a' GHC.Classes.==) c
                                        then
                                          let readFail = readFail
                                           in let !(# c, cs #) = readNext cs
                                               in if ('b' GHC.Classes.==) c
                                                    then
                                                      let readFail = readFail
                                                       in let !(#
                                                                 c,
                                                                 cs
                                                                 #) = readNext cs
                                                           in if ('c' GHC.Classes.==) c
                                                                then
                                                                  let _ = "resume"
                                                                   in finalRet init GHC.Types
                                                                        . []
                                                                          ( let _ = "resume.genCode"
                                                                             in GHC.Show.show ('a' GHC.Types.: ('b' GHC.Types.: ('c' GHC.Types.: GHC.Types . [])))
                                                                          )
                                                                          cs
                                                                else
                                                                  let _ = "checkToken.else"
                                                                   in let (#
                                                                            farInp,
                                                                            farExp
                                                                            #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init cs of
                                                                              GHC.Types.LT ->
                                                                                (#
                                                                                  cs,
                                                                                  [Symantic.Parser.Grammar.Combinators.ErrorItemToken 'c']
                                                                                #)
                                                                              GHC.Types.EQ ->
                                                                                (#
                                                                                  init,
                                                                                  GHC.Types . [] GHC.Base.<> [Symantic.Parser.Grammar.Combinators.ErrorItemToken 'c']
                                                                                #)
                                                                              GHC.Types.GT ->
                                                                                (#
                                                                                  init,
                                                                                  GHC.Types . []
                                                                                #)
                                                                       in readFail cs farInp farExp
                                                    else
                                                      let _ = "checkToken.else"
                                                       in let (#
                                                                farInp,
                                                                farExp
                                                                #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init cs of
                                                                  GHC.Types.LT ->
                                                                    (#
                                                                      cs,
                                                                      [Symantic.Parser.Grammar.Combinators.ErrorItemToken 'b']
                                                                    #)
                                                                  GHC.Types.EQ ->
                                                                    (#
                                                                      init,
                                                                      GHC.Types . [] GHC.Base.<> [Symantic.Parser.Grammar.Combinators.ErrorItemToken 'b']
                                                                    #)
                                                                  GHC.Types.GT ->
                                                                    (#
                                                                      init,
                                                                      GHC.Types . []
                                                                    #)
                                                           in readFail cs farInp farExp
                                        else
                                          let _ = "checkToken.else"
                                           in let (#
                                                    farInp,
                                                    farExp
                                                    #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init init of
                                                      GHC.Types.LT ->
                                                        (#
                                                          init,
                                                          [Symantic.Parser.Grammar.Combinators.ErrorItemToken 'a']
                                                        #)
                                                      GHC.Types.EQ ->
                                                        (#
                                                          init,
                                                          GHC.Types . [] GHC.Base.<> [Symantic.Parser.Grammar.Combinators.ErrorItemToken 'a']
                                                        #)
                                                      GHC.Types.GT ->
                                                        (#
                                                          init,
                                                          GHC.Types . []
                                                        #)
                                               in readFail init farInp farExp
                                else
                                  let _ = "checkHorizon.else"
                                   in let (#
                                            farInp,
                                            farExp
                                            #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init init of
                                              GHC.Types.LT ->
                                                (#
                                                  init,
                                                  [Symantic.Parser.Grammar.Combinators.ErrorItemHorizon 3]
                                                #)
                                              GHC.Types.EQ ->
                                                (#
                                                  init,
                                                  GHC.Types . [] GHC.Base.<> [Symantic.Parser.Grammar.Combinators.ErrorItemHorizon 3]
                                                #)
                                              GHC.Types.GT ->
                                                (#
                                                  init,
                                                  GHC.Types . []
                                                #)
                                       in readFail init farInp farExp