\(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 name = \(!ok) (!inp) (!koByLabel) ->
                    name
                      ( let _ = "suspend"
                         in \farInp farExp v (!inp) ->
                              let _ = "resume"
                               in ok
                                    farInp
                                    farExp
                                    ( let _ = "resume.genCode"
                                       in GHC.Tuple . ()
                                    )
                                    inp
                      )
                      inp
                      Data.Map.Internal.Tip
                  name = \(!ok) (!inp) (!koByLabel) ->
                    name
                      ( let _ = "suspend"
                         in \farInp farExp v (!inp) ->
                              let _ = "resume"
                               in ok
                                    farInp
                                    farExp
                                    ( let _ = "resume.genCode"
                                       in v GHC.Types . []
                                    )
                                    inp
                      )
                      inp
                      Data.Map.Internal.Tip
                  name = \(!ok) (!inp) (!koByLabel) ->
                    let _ = "catchException lbl=fail"
                     in let catchHandler (!failInp) (!farInp) (!farExp) =
                              let _ = "catchException.ko lbl=fail"
                               in if ( \( Data.Text.Internal.Text
                                            _
                                            i
                                            _
                                          )
                                        ( Data.Text.Internal.Text
                                            _
                                            j
                                            _
                                          ) -> i GHC.Classes.== j
                                     )
                                    inp
                                    failInp
                                    then
                                      let _ = "choicesBranch.then"
                                       in let _ = "resume"
                                           in ok
                                                farInp
                                                farExp
                                                ( let _ = "resume.genCode"
                                                   in \x -> x
                                                )
                                                failInp
                                    else
                                      let _ = "choicesBranch.else"
                                       in let (#
                                                farInp,
                                                farExp
                                                #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp failInp of
                                                  GHC.Types.LT ->
                                                    (#
                                                      failInp,
                                                      []
                                                    #)
                                                  GHC.Types.EQ ->
                                                    (#
                                                      farInp,
                                                      farExp GHC.Base.<> []
                                                    #)
                                                  GHC.Types.GT ->
                                                    (#
                                                      farInp,
                                                      farExp
                                                    #)
                                           in finalRaise failInp farInp farExp
                         in let join = \farInp farExp v (!inp) ->
                                  name
                                    ( let _ = "suspend"
                                       in \farInp farExp v (!inp) ->
                                            name
                                              ( let _ = "suspend"
                                                 in \farInp farExp v (!inp) ->
                                                      let _ = "resume"
                                                       in ok
                                                            farInp
                                                            farExp
                                                            ( let _ = "resume.genCode"
                                                               in \x -> v GHC.Types.: v x
                                                            )
                                                            inp
                                              )
                                              inp
                                              Data.Map.Internal.Tip
                                    )
                                    inp
                                    Data.Map.Internal.Tip
                             in let readFail = catchHandler
                                 in if readMore inp
                                      then
                                        let !(#
                                               c,
                                               cs
                                               #) = readNext inp
                                         in if (\x -> \x -> x) GHC.Types.True c
                                              then
                                                if '>' GHC.Classes.== c
                                                  then
                                                    let _ = "choicesBranch.then"
                                                     in let readFail = readFail
                                                         in if readMore inp
                                                              then
                                                                let !(#
                                                                       c,
                                                                       cs
                                                                       #) = readNext inp
                                                                 in if (\x -> \x -> x) GHC.Types.True c
                                                                      then
                                                                        let _ = "resume"
                                                                         in join init GHC.Types
                                                                              . []
                                                                                ( let _ = "resume.genCode"
                                                                                   in Grammar.Brainfuck.RightPointer
                                                                                )
                                                                                cs
                                                                      else
                                                                        let _ = "checkToken.else"
                                                                         in let (#
                                                                                  farInp,
                                                                                  farExp
                                                                                  #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of
                                                                                    GHC.Types.LT ->
                                                                                      (#
                                                                                        inp,
                                                                                        []
                                                                                      #)
                                                                                    GHC.Types.EQ ->
                                                                                      (#
                                                                                        init,
                                                                                        GHC.Types . [] GHC.Base.<> []
                                                                                      #)
                                                                                    GHC.Types.GT ->
                                                                                      (#
                                                                                        init,
                                                                                        GHC.Types . []
                                                                                      #)
                                                                             in readFail inp farInp farExp
                                                              else
                                                                let _ = "checkHorizon.else"
                                                                 in let (#
                                                                          farInp,
                                                                          farExp
                                                                          #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of
                                                                            GHC.Types.LT ->
                                                                              (#
                                                                                inp,
                                                                                [Symantic.Parser.Grammar.Combinators.ErrorItemHorizon 1]
                                                                              #)
                                                                            GHC.Types.EQ ->
                                                                              (#
                                                                                init,
                                                                                GHC.Types . [] GHC.Base.<> [Symantic.Parser.Grammar.Combinators.ErrorItemHorizon 1]
                                                                              #)
                                                                            GHC.Types.GT ->
                                                                              (#
                                                                                init,
                                                                                GHC.Types . []
                                                                              #)
                                                                     in readFail inp farInp farExp
                                                  else
                                                    let _ = "choicesBranch.else"
                                                     in if '<' GHC.Classes.== c
                                                          then
                                                            let _ = "choicesBranch.then"
                                                             in let readFail = readFail
                                                                 in if readMore inp
                                                                      then
                                                                        let !(#
                                                                               c,
                                                                               cs
                                                                               #) = readNext inp
                                                                         in if (\x -> \x -> x) GHC.Types.True c
                                                                              then
                                                                                let _ = "resume"
                                                                                 in join init GHC.Types
                                                                                      . []
                                                                                        ( let _ = "resume.genCode"
                                                                                           in Grammar.Brainfuck.LeftPointer
                                                                                        )
                                                                                        cs
                                                                              else
                                                                                let _ = "checkToken.else"
                                                                                 in let (#
                                                                                          farInp,
                                                                                          farExp
                                                                                          #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of
                                                                                            GHC.Types.LT ->
                                                                                              (#
                                                                                                inp,
                                                                                                []
                                                                                              #)
                                                                                            GHC.Types.EQ ->
                                                                                              (#
                                                                                                init,
                                                                                                GHC.Types . [] GHC.Base.<> []
                                                                                              #)
                                                                                            GHC.Types.GT ->
                                                                                              (#
                                                                                                init,
                                                                                                GHC.Types . []
                                                                                              #)
                                                                                     in readFail inp farInp farExp
                                                                      else
                                                                        let _ = "checkHorizon.else"
                                                                         in let (#
                                                                                  farInp,
                                                                                  farExp
                                                                                  #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of
                                                                                    GHC.Types.LT ->
                                                                                      (#
                                                                                        inp,
                                                                                        [Symantic.Parser.Grammar.Combinators.ErrorItemHorizon 1]
                                                                                      #)
                                                                                    GHC.Types.EQ ->
                                                                                      (#
                                                                                        init,
                                                                                        GHC.Types . [] GHC.Base.<> [Symantic.Parser.Grammar.Combinators.ErrorItemHorizon 1]
                                                                                      #)
                                                                                    GHC.Types.GT ->
                                                                                      (#
                                                                                        init,
                                                                                        GHC.Types . []
                                                                                      #)
                                                                             in readFail inp farInp farExp
                                                          else
                                                            let _ = "choicesBranch.else"
                                                             in if '+' GHC.Classes.== c
                                                                  then
                                                                    let _ = "choicesBranch.then"
                                                                     in let readFail = readFail
                                                                         in if readMore inp
                                                                              then
                                                                                let !(#
                                                                                       c,
                                                                                       cs
                                                                                       #) = readNext inp
                                                                                 in if (\x -> \x -> x) GHC.Types.True c
                                                                                      then
                                                                                        let _ = "resume"
                                                                                         in join init GHC.Types
                                                                                              . []
                                                                                                ( let _ = "resume.genCode"
                                                                                                   in Grammar.Brainfuck.Increment
                                                                                                )
                                                                                                cs
                                                                                      else
                                                                                        let _ = "checkToken.else"
                                                                                         in let (#
                                                                                                  farInp,
                                                                                                  farExp
                                                                                                  #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of
                                                                                                    GHC.Types.LT ->
                                                                                                      (#
                                                                                                        inp,
                                                                                                        []
                                                                                                      #)
                                                                                                    GHC.Types.EQ ->
                                                                                                      (#
                                                                                                        init,
                                                                                                        GHC.Types . [] GHC.Base.<> []
                                                                                                      #)
                                                                                                    GHC.Types.GT ->
                                                                                                      (#
                                                                                                        init,
                                                                                                        GHC.Types . []
                                                                                                      #)
                                                                                             in readFail inp farInp farExp
                                                                              else
                                                                                let _ = "checkHorizon.else"
                                                                                 in let (#
                                                                                          farInp,
                                                                                          farExp
                                                                                          #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of
                                                                                            GHC.Types.LT ->
                                                                                              (#
                                                                                                inp,
                                                                                                [Symantic.Parser.Grammar.Combinators.ErrorItemHorizon 1]
                                                                                              #)
                                                                                            GHC.Types.EQ ->
                                                                                              (#
                                                                                                init,
                                                                                                GHC.Types . [] GHC.Base.<> [Symantic.Parser.Grammar.Combinators.ErrorItemHorizon 1]
                                                                                              #)
                                                                                            GHC.Types.GT ->
                                                                                              (#
                                                                                                init,
                                                                                                GHC.Types . []
                                                                                              #)
                                                                                     in readFail inp farInp farExp
                                                                  else
                                                                    let _ = "choicesBranch.else"
                                                                     in if '-' GHC.Classes.== c
                                                                          then
                                                                            let _ = "choicesBranch.then"
                                                                             in let readFail = readFail
                                                                                 in if readMore inp
                                                                                      then
                                                                                        let !(#
                                                                                               c,
                                                                                               cs
                                                                                               #) = readNext inp
                                                                                         in if (\x -> \x -> x) GHC.Types.True c
                                                                                              then
                                                                                                let _ = "resume"
                                                                                                 in join init GHC.Types
                                                                                                      . []
                                                                                                        ( let _ = "resume.genCode"
                                                                                                           in Grammar.Brainfuck.Decrement
                                                                                                        )
                                                                                                        cs
                                                                                              else
                                                                                                let _ = "checkToken.else"
                                                                                                 in let (#
                                                                                                          farInp,
                                                                                                          farExp
                                                                                                          #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of
                                                                                                            GHC.Types.LT ->
                                                                                                              (#
                                                                                                                inp,
                                                                                                                []
                                                                                                              #)
                                                                                                            GHC.Types.EQ ->
                                                                                                              (#
                                                                                                                init,
                                                                                                                GHC.Types . [] GHC.Base.<> []
                                                                                                              #)
                                                                                                            GHC.Types.GT ->
                                                                                                              (#
                                                                                                                init,
                                                                                                                GHC.Types . []
                                                                                                              #)
                                                                                                     in readFail inp farInp farExp
                                                                                      else
                                                                                        let _ = "checkHorizon.else"
                                                                                         in let (#
                                                                                                  farInp,
                                                                                                  farExp
                                                                                                  #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of
                                                                                                    GHC.Types.LT ->
                                                                                                      (#
                                                                                                        inp,
                                                                                                        [Symantic.Parser.Grammar.Combinators.ErrorItemHorizon 1]
                                                                                                      #)
                                                                                                    GHC.Types.EQ ->
                                                                                                      (#
                                                                                                        init,
                                                                                                        GHC.Types . [] GHC.Base.<> [Symantic.Parser.Grammar.Combinators.ErrorItemHorizon 1]
                                                                                                      #)
                                                                                                    GHC.Types.GT ->
                                                                                                      (#
                                                                                                        init,
                                                                                                        GHC.Types . []
                                                                                                      #)
                                                                                             in readFail inp farInp farExp
                                                                          else
                                                                            let _ = "choicesBranch.else"
                                                                             in if '.' GHC.Classes.== c
                                                                                  then
                                                                                    let _ = "choicesBranch.then"
                                                                                     in let readFail = readFail
                                                                                         in if readMore inp
                                                                                              then
                                                                                                let !(#
                                                                                                       c,
                                                                                                       cs
                                                                                                       #) = readNext inp
                                                                                                 in if (\x -> \x -> x) GHC.Types.True c
                                                                                                      then
                                                                                                        let _ = "resume"
                                                                                                         in join init GHC.Types
                                                                                                              . []
                                                                                                                ( let _ = "resume.genCode"
                                                                                                                   in Grammar.Brainfuck.Output
                                                                                                                )
                                                                                                                cs
                                                                                                      else
                                                                                                        let _ = "checkToken.else"
                                                                                                         in let (#
                                                                                                                  farInp,
                                                                                                                  farExp
                                                                                                                  #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of
                                                                                                                    GHC.Types.LT ->
                                                                                                                      (#
                                                                                                                        inp,
                                                                                                                        []
                                                                                                                      #)
                                                                                                                    GHC.Types.EQ ->
                                                                                                                      (#
                                                                                                                        init,
                                                                                                                        GHC.Types . [] GHC.Base.<> []
                                                                                                                      #)
                                                                                                                    GHC.Types.GT ->
                                                                                                                      (#
                                                                                                                        init,
                                                                                                                        GHC.Types . []
                                                                                                                      #)
                                                                                                             in readFail inp farInp farExp
                                                                                              else
                                                                                                let _ = "checkHorizon.else"
                                                                                                 in let (#
                                                                                                          farInp,
                                                                                                          farExp
                                                                                                          #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of
                                                                                                            GHC.Types.LT ->
                                                                                                              (#
                                                                                                                inp,
                                                                                                                [Symantic.Parser.Grammar.Combinators.ErrorItemHorizon 1]
                                                                                                              #)
                                                                                                            GHC.Types.EQ ->
                                                                                                              (#
                                                                                                                init,
                                                                                                                GHC.Types . [] GHC.Base.<> [Symantic.Parser.Grammar.Combinators.ErrorItemHorizon 1]
                                                                                                              #)
                                                                                                            GHC.Types.GT ->
                                                                                                              (#
                                                                                                                init,
                                                                                                                GHC.Types . []
                                                                                                              #)
                                                                                                     in readFail inp farInp farExp
                                                                                  else
                                                                                    let _ = "choicesBranch.else"
                                                                                     in if ',' GHC.Classes.== c
                                                                                          then
                                                                                            let _ = "choicesBranch.then"
                                                                                             in let readFail = readFail
                                                                                                 in if readMore inp
                                                                                                      then
                                                                                                        let !(#
                                                                                                               c,
                                                                                                               cs
                                                                                                               #) = readNext inp
                                                                                                         in if (\x -> \x -> x) GHC.Types.True c
                                                                                                              then
                                                                                                                let _ = "resume"
                                                                                                                 in join init GHC.Types
                                                                                                                      . []
                                                                                                                        ( let _ = "resume.genCode"
                                                                                                                           in Grammar.Brainfuck.Input
                                                                                                                        )
                                                                                                                        cs
                                                                                                              else
                                                                                                                let _ = "checkToken.else"
                                                                                                                 in let (#
                                                                                                                          farInp,
                                                                                                                          farExp
                                                                                                                          #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of
                                                                                                                            GHC.Types.LT ->
                                                                                                                              (#
                                                                                                                                inp,
                                                                                                                                []
                                                                                                                              #)
                                                                                                                            GHC.Types.EQ ->
                                                                                                                              (#
                                                                                                                                init,
                                                                                                                                GHC.Types . [] GHC.Base.<> []
                                                                                                                              #)
                                                                                                                            GHC.Types.GT ->
                                                                                                                              (#
                                                                                                                                init,
                                                                                                                                GHC.Types . []
                                                                                                                              #)
                                                                                                                     in readFail inp farInp farExp
                                                                                                      else
                                                                                                        let _ = "checkHorizon.else"
                                                                                                         in let (#
                                                                                                                  farInp,
                                                                                                                  farExp
                                                                                                                  #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of
                                                                                                                    GHC.Types.LT ->
                                                                                                                      (#
                                                                                                                        inp,
                                                                                                                        [Symantic.Parser.Grammar.Combinators.ErrorItemHorizon 1]
                                                                                                                      #)
                                                                                                                    GHC.Types.EQ ->
                                                                                                                      (#
                                                                                                                        init,
                                                                                                                        GHC.Types . [] GHC.Base.<> [Symantic.Parser.Grammar.Combinators.ErrorItemHorizon 1]
                                                                                                                      #)
                                                                                                                    GHC.Types.GT ->
                                                                                                                      (#
                                                                                                                        init,
                                                                                                                        GHC.Types . []
                                                                                                                      #)
                                                                                                             in readFail inp farInp farExp
                                                                                          else
                                                                                            let _ = "choicesBranch.else"
                                                                                             in if '[' GHC.Classes.== c
                                                                                                  then
                                                                                                    let _ = "choicesBranch.then"
                                                                                                     in let readFail = readFail
                                                                                                         in if readMore (Symantic.Parser.Machine.Input.shiftRightText 1 inp)
                                                                                                              then
                                                                                                                let !(#
                                                                                                                       c,
                                                                                                                       cs
                                                                                                                       #) = readNext inp
                                                                                                                 in if (\x -> \x -> x) GHC.Types.True c
                                                                                                                      then
                                                                                                                        name
                                                                                                                          ( let _ = "suspend"
                                                                                                                             in \farInp farExp v (!inp) ->
                                                                                                                                  name
                                                                                                                                    ( let _ = "suspend"
                                                                                                                                       in \farInp farExp v (!inp) ->
                                                                                                                                            let readFail = readFail
                                                                                                                                             in if readMore inp
                                                                                                                                                  then
                                                                                                                                                    let !(#
                                                                                                                                                           c,
                                                                                                                                                           cs
                                                                                                                                                           #) = readNext inp
                                                                                                                                                     in if (']' GHC.Classes.==) c
                                                                                                                                                          then
                                                                                                                                                            let _ = "resume"
                                                                                                                                                             in join
                                                                                                                                                                  farInp
                                                                                                                                                                  farExp
                                                                                                                                                                  ( let _ = "resume.genCode"
                                                                                                                                                                     in Grammar.Brainfuck.Loop v
                                                                                                                                                                  )
                                                                                                                                                                  cs
                                                                                                                                                          else
                                                                                                                                                            let _ = "checkToken.else"
                                                                                                                                                             in let (#
                                                                                                                                                                      farInp,
                                                                                                                                                                      farExp
                                                                                                                                                                      #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp inp of
                                                                                                                                                                        GHC.Types.LT ->
                                                                                                                                                                          (#
                                                                                                                                                                            inp,
                                                                                                                                                                            [Symantic.Parser.Grammar.Combinators.ErrorItemToken ']']
                                                                                                                                                                          #)
                                                                                                                                                                        GHC.Types.EQ ->
                                                                                                                                                                          (#
                                                                                                                                                                            farInp,
                                                                                                                                                                            farExp GHC.Base.<> [Symantic.Parser.Grammar.Combinators.ErrorItemToken ']']
                                                                                                                                                                          #)
                                                                                                                                                                        GHC.Types.GT ->
                                                                                                                                                                          (#
                                                                                                                                                                            farInp,
                                                                                                                                                                            farExp
                                                                                                                                                                          #)
                                                                                                                                                                 in readFail inp farInp farExp
                                                                                                                                                  else
                                                                                                                                                    let _ = "checkHorizon.else"
                                                                                                                                                     in let (#
                                                                                                                                                              farInp,
                                                                                                                                                              farExp
                                                                                                                                                              #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp inp of
                                                                                                                                                                GHC.Types.LT ->
                                                                                                                                                                  (#
                                                                                                                                                                    inp,
                                                                                                                                                                    [Symantic.Parser.Grammar.Combinators.ErrorItemHorizon 1]
                                                                                                                                                                  #)
                                                                                                                                                                GHC.Types.EQ ->
                                                                                                                                                                  (#
                                                                                                                                                                    farInp,
                                                                                                                                                                    farExp GHC.Base.<> [Symantic.Parser.Grammar.Combinators.ErrorItemHorizon 1]
                                                                                                                                                                  #)
                                                                                                                                                                GHC.Types.GT ->
                                                                                                                                                                  (#
                                                                                                                                                                    farInp,
                                                                                                                                                                    farExp
                                                                                                                                                                  #)
                                                                                                                                                         in readFail inp farInp farExp
                                                                                                                                    )
                                                                                                                                    inp
                                                                                                                                    Data.Map.Internal.Tip
                                                                                                                          )
                                                                                                                          cs
                                                                                                                          Data.Map.Internal.Tip
                                                                                                                      else
                                                                                                                        let _ = "checkToken.else"
                                                                                                                         in let (#
                                                                                                                                  farInp,
                                                                                                                                  farExp
                                                                                                                                  #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of
                                                                                                                                    GHC.Types.LT ->
                                                                                                                                      (#
                                                                                                                                        inp,
                                                                                                                                        []
                                                                                                                                      #)
                                                                                                                                    GHC.Types.EQ ->
                                                                                                                                      (#
                                                                                                                                        init,
                                                                                                                                        GHC.Types . [] GHC.Base.<> []
                                                                                                                                      #)
                                                                                                                                    GHC.Types.GT ->
                                                                                                                                      (#
                                                                                                                                        init,
                                                                                                                                        GHC.Types . []
                                                                                                                                      #)
                                                                                                                             in readFail inp farInp farExp
                                                                                                              else
                                                                                                                let _ = "checkHorizon.else"
                                                                                                                 in let (#
                                                                                                                          farInp,
                                                                                                                          farExp
                                                                                                                          #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of
                                                                                                                            GHC.Types.LT ->
                                                                                                                              (#
                                                                                                                                inp,
                                                                                                                                [Symantic.Parser.Grammar.Combinators.ErrorItemHorizon 2]
                                                                                                                              #)
                                                                                                                            GHC.Types.EQ ->
                                                                                                                              (#
                                                                                                                                init,
                                                                                                                                GHC.Types . [] GHC.Base.<> [Symantic.Parser.Grammar.Combinators.ErrorItemHorizon 2]
                                                                                                                              #)
                                                                                                                            GHC.Types.GT ->
                                                                                                                              (#
                                                                                                                                init,
                                                                                                                                GHC.Types . []
                                                                                                                              #)
                                                                                                                     in readFail inp farInp farExp
                                                                                                  else
                                                                                                    let _ = "choicesBranch.else"
                                                                                                     in let (#
                                                                                                              farInp,
                                                                                                              farExp
                                                                                                              #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of
                                                                                                                GHC.Types.LT ->
                                                                                                                  (#
                                                                                                                    inp,
                                                                                                                    []
                                                                                                                  #)
                                                                                                                GHC.Types.EQ ->
                                                                                                                  (#
                                                                                                                    init,
                                                                                                                    GHC.Types . [] GHC.Base.<> []
                                                                                                                  #)
                                                                                                                GHC.Types.GT ->
                                                                                                                  (#
                                                                                                                    init,
                                                                                                                    GHC.Types . []
                                                                                                                  #)
                                                                                                         in readFail inp farInp farExp
                                              else
                                                let _ = "checkToken.else"
                                                 in let (#
                                                          farInp,
                                                          farExp
                                                          #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of
                                                            GHC.Types.LT ->
                                                              (#
                                                                inp,
                                                                []
                                                              #)
                                                            GHC.Types.EQ ->
                                                              (#
                                                                init,
                                                                GHC.Types . [] GHC.Base.<> []
                                                              #)
                                                            GHC.Types.GT ->
                                                              (#
                                                                init,
                                                                GHC.Types . []
                                                              #)
                                                     in readFail inp farInp farExp
                                      else
                                        let _ = "checkHorizon.else"
                                         in let (#
                                                  farInp,
                                                  farExp
                                                  #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of
                                                    GHC.Types.LT ->
                                                      (#
                                                        inp,
                                                        [Symantic.Parser.Grammar.Combinators.ErrorItemHorizon 1]
                                                      #)
                                                    GHC.Types.EQ ->
                                                      (#
                                                        init,
                                                        GHC.Types . [] GHC.Base.<> [Symantic.Parser.Grammar.Combinators.ErrorItemHorizon 1]
                                                      #)
                                                    GHC.Types.GT ->
                                                      (#
                                                        init,
                                                        GHC.Types . []
                                                      #)
                                             in readFail inp farInp farExp
                  name = \(!ok) (!inp) (!koByLabel) ->
                    let _ = "catchException lbl=fail"
                     in let catchHandler (!failInp) (!farInp) (!farExp) =
                              let _ = "catchException.ko lbl=fail"
                               in if ( \( Data.Text.Internal.Text
                                            _
                                            i
                                            _
                                          )
                                        ( Data.Text.Internal.Text
                                            _
                                            j
                                            _
                                          ) -> i GHC.Classes.== j
                                     )
                                    inp
                                    failInp
                                    then
                                      let _ = "choicesBranch.then"
                                       in let _ = "resume"
                                           in ok
                                                farInp
                                                farExp
                                                ( let _ = "resume.genCode"
                                                   in \x -> x
                                                )
                                                failInp
                                    else
                                      let _ = "choicesBranch.else"
                                       in let (#
                                                farInp,
                                                farExp
                                                #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp failInp of
                                                  GHC.Types.LT ->
                                                    (#
                                                      failInp,
                                                      []
                                                    #)
                                                  GHC.Types.EQ ->
                                                    (#
                                                      farInp,
                                                      farExp GHC.Base.<> []
                                                    #)
                                                  GHC.Types.GT ->
                                                    (#
                                                      farInp,
                                                      farExp
                                                    #)
                                           in finalRaise failInp farInp farExp
                         in let readFail = catchHandler
                             in if readMore inp
                                  then
                                    let !(#
                                           c,
                                           cs
                                           #) = readNext inp
                                     in if (\c -> GHC.Classes.not (('<' GHC.Classes.== c) GHC.Classes.|| (('>' GHC.Classes.== c) GHC.Classes.|| (('+' GHC.Classes.== c) GHC.Classes.|| (('-' GHC.Classes.== c) GHC.Classes.|| (('[' GHC.Classes.== c) GHC.Classes.|| ((']' GHC.Classes.== c) GHC.Classes.|| ((',' GHC.Classes.== c) GHC.Classes.|| (('.' GHC.Classes.== c) GHC.Classes.|| (('$' GHC.Classes.== c) GHC.Classes.|| GHC.Types.False)))))))))) c
                                          then
                                            name
                                              ( let _ = "suspend"
                                                 in \farInp farExp v (!inp) ->
                                                      let _ = "resume"
                                                       in ok
                                                            farInp
                                                            farExp
                                                            ( let _ = "resume.genCode"
                                                               in \x -> v x
                                                            )
                                                            inp
                                              )
                                              cs
                                              Data.Map.Internal.Tip
                                          else
                                            let _ = "checkToken.else"
                                             in let (#
                                                      farInp,
                                                      farExp
                                                      #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of
                                                        GHC.Types.LT ->
                                                          (#
                                                            inp,
                                                            [ Symantic.Parser.Grammar.Combinators.ErrorItemToken '<',
                                                              Symantic.Parser.Grammar.Combinators.ErrorItemToken '>',
                                                              Symantic.Parser.Grammar.Combinators.ErrorItemToken '+',
                                                              Symantic.Parser.Grammar.Combinators.ErrorItemToken '-',
                                                              Symantic.Parser.Grammar.Combinators.ErrorItemToken '[',
                                                              Symantic.Parser.Grammar.Combinators.ErrorItemToken ']',
                                                              Symantic.Parser.Grammar.Combinators.ErrorItemToken ',',
                                                              Symantic.Parser.Grammar.Combinators.ErrorItemToken '.',
                                                              Symantic.Parser.Grammar.Combinators.ErrorItemToken '$'
                                                            ]
                                                          #)
                                                        GHC.Types.EQ ->
                                                          (#
                                                            init,
                                                            GHC.Types . []
                                                              GHC.Base.<> [ Symantic.Parser.Grammar.Combinators.ErrorItemToken '<',
                                                                            Symantic.Parser.Grammar.Combinators.ErrorItemToken '>',
                                                                            Symantic.Parser.Grammar.Combinators.ErrorItemToken '+',
                                                                            Symantic.Parser.Grammar.Combinators.ErrorItemToken '-',
                                                                            Symantic.Parser.Grammar.Combinators.ErrorItemToken '[',
                                                                            Symantic.Parser.Grammar.Combinators.ErrorItemToken ']',
                                                                            Symantic.Parser.Grammar.Combinators.ErrorItemToken ',',
                                                                            Symantic.Parser.Grammar.Combinators.ErrorItemToken '.',
                                                                            Symantic.Parser.Grammar.Combinators.ErrorItemToken '$'
                                                                          ]
                                                          #)
                                                        GHC.Types.GT ->
                                                          (#
                                                            init,
                                                            GHC.Types . []
                                                          #)
                                                 in readFail inp farInp farExp
                                  else
                                    let _ = "checkHorizon.else"
                                     in let (#
                                              farInp,
                                              farExp
                                              #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of
                                                GHC.Types.LT ->
                                                  (#
                                                    inp,
                                                    [Symantic.Parser.Grammar.Combinators.ErrorItemHorizon 1]
                                                  #)
                                                GHC.Types.EQ ->
                                                  (#
                                                    init,
                                                    GHC.Types . [] GHC.Base.<> [Symantic.Parser.Grammar.Combinators.ErrorItemHorizon 1]
                                                  #)
                                                GHC.Types.GT ->
                                                  (#
                                                    init,
                                                    GHC.Types . []
                                                  #)
                                         in readFail inp farInp farExp
               in name
                    ( let _ = "suspend"
                       in \farInp farExp v (!inp) ->
                            name
                              ( let _ = "suspend"
                                 in \farInp farExp v (!inp) ->
                                      let _ = "resume"
                                       in finalRet
                                            farInp
                                            farExp
                                            ( let _ = "resume.genCode"
                                               in GHC.Show.show v
                                            )
                                            inp
                              )
                              inp
                              Data.Map.Internal.Tip
                    )
                    init
                    Data.Map.Internal.Tip