\(input_0 :: inp_6989586621679040759) ->
  let !(#
         init_1,
         readMore_2,
         readNext_3
         #) =
          let _ = "cursorOf"
           in let next_4
                    ( t_5@( Data.Text.Internal.Text
                              arr_6
                              off_7
                              unconsumed_8
                            )
                      ) =
                      let !( Data.Text.Unsafe.Iter
                               c_9
                               d_10
                             ) = Data.Text.Unsafe.iter t_5 0
                       in (#
                            c_9,
                            Data.Text.Internal.Text arr_6 (off_7 GHC.Num.+ d_10) (unconsumed_8 GHC.Num.- d_10)
                          #)
                  more_11
                    ( Data.Text.Internal.Text
                        _
                        _
                        unconsumed_12
                      ) = unconsumed_12 GHC.Classes.> 0
               in (#
                    input_0,
                    more_11,
                    next_4
                  #)
      finalRet_13 = \_farInp_14 _farExp_15 v_16 _inp_17 -> Symantic.Parser.Machine.Generate.returnST GHC.Base.$ Data.Either.Right v_16
      finalRaise_18 ::
        forall st_19 b_20.
        Symantic.Parser.Machine.Generate.Catcher
          st_19
          inp_6989586621679040759
          b_20 = \(!exn_21) _failInp_22 (!farInp_23) (!farExp_24) ->
          Symantic.Parser.Machine.Generate.returnST GHC.Base.$
            Data.Either.Left
              Symantic.Parser.Machine.Generate.ParsingError
                { Symantic.Parser.Machine.Generate.parsingErrorOffset = Symantic.Parser.Machine.Input.offset farInp_23,
                  Symantic.Parser.Machine.Generate.parsingErrorException = exn_21,
                  Symantic.Parser.Machine.Generate.parsingErrorUnexpected =
                    if readMore_2 farInp_23
                      then
                        GHC.Maybe.Just
                          ( let (#
                                  c_25,
                                  _
                                  #) = readNext_3 farInp_23
                             in c_25
                          )
                      else GHC.Maybe.Nothing,
                  Symantic.Parser.Machine.Generate.parsingErrorExpecting =
                    let ( minHoriz_26,
                          res_27
                          ) =
                            Data.Set.Internal.foldr
                              ( \f_28
                                 ( minH_29,
                                   acc_30
                                   ) -> case Symantic.Parser.Grammar.Combinators.unSomeFailure f_28 of
                                    GHC.Maybe.Just (Symantic.Parser.Grammar.Combinators.FailureHorizon h_31 :: Symantic.Parser.Grammar.Combinators.Failure (Symantic.Parser.Grammar.Combinators.CombSatisfiable (Symantic.Parser.Machine.Input.InputToken inp_6989586621679040759)))
                                      | GHC.Maybe.Just old_32 <- minH_29 ->
                                        ( GHC.Maybe.Just (GHC.Classes.min old_32 h_31),
                                          acc_30
                                        )
                                      | GHC.Base.otherwise ->
                                        ( GHC.Maybe.Just h_31,
                                          acc_30
                                        )
                                    _ ->
                                      ( minH_29,
                                        f_28 GHC.Types.: acc_30
                                      )
                              )
                              ( GHC.Maybe.Nothing,
                                GHC.Types . []
                              )
                              farExp_24
                     in Data.Set.Internal.fromList GHC.Base.$
                          ( case minHoriz_26 of
                              GHC.Maybe.Just h_33 -> Symantic.Parser.Grammar.Combinators.SomeFailure (Symantic.Parser.Grammar.Combinators.FailureHorizon @(Symantic.Parser.Machine.Input.InputToken inp_6989586621679040759) h_33) GHC.Types.: res_27
                              GHC.Maybe.Nothing -> res_27
                          )
                }
   in GHC.ST.runST
        ( let inputToken = Data.Proxy.Proxy :: Data.Proxy.Proxy (Symantic.Parser.Machine.Input.InputToken inp_6989586621679040759)
           in let _ = "checkHorizon.noCheck"
               in let
                   in let _ = "pushValue"
                       in let join_34 = \farInp_35 farExp_36 v_37 (!inp_38) ->
                                let _ = "resume"
                                 in finalRet_13
                                      farInp_35
                                      farExp_36
                                      ( let _ = "resume.genCode"
                                         in GHC.Show.show v_37
                                      )
                                      inp_38
                           in let _ = "catch ExceptionFailure"
                               in let catchHandler_39 (!_exn_40) (!failInp_41) (!farInp_42) (!farExp_43) =
                                        let _ = "catch.ko ExceptionFailure"
                                         in let _ = "pushInput"
                                             in if ( \( Data.Text.Internal.Text
                                                          _
                                                          i_44
                                                          _
                                                        )
                                                      ( Data.Text.Internal.Text
                                                          _
                                                          j_45
                                                          _
                                                        ) -> i_44 GHC.Classes.== j_45
                                                   )
                                                  init_1
                                                  failInp_41
                                                  then
                                                    let _ = "choicesBranch.then"
                                                     in let _ = "pushValue"
                                                         in let _ = "comment: satisfy"
                                                             in let inp_46 = failInp_41
                                                                 in let readFail_47 = finalRaise_18
                                                                     in let _ = "checkHorizon.newCheck: checkedHorizon=0 minHoriz=2"
                                                                         in if readMore_2 (Symantic.Parser.Machine.Input.shiftRightText 1 inp_46)
                                                                              then
                                                                                let _ = "checkToken"
                                                                                 in let !(#
                                                                                           c_48,
                                                                                           cs_49
                                                                                           #) = readNext_3 inp_46
                                                                                     in if (GHC.Classes.==) 'a' c_48
                                                                                          then
                                                                                            let _ = "comment: satisfy"
                                                                                             in let _ = "checkHorizon.oldCheck: checkedHorizon=2"
                                                                                                 in let _ = "checkToken"
                                                                                                     in let !(#
                                                                                                               c_50,
                                                                                                               cs_51
                                                                                                               #) = readNext_3 cs_49
                                                                                                         in if (GHC.Classes.==) 'b' c_50
                                                                                                              then
                                                                                                                let _ = "resume"
                                                                                                                 in join_34
                                                                                                                      farInp_42
                                                                                                                      farExp_43
                                                                                                                      ( let _ = "resume.genCode"
                                                                                                                         in (GHC.Types.:) 'a' ((GHC.Types.:) 'b' GHC.Types . [])
                                                                                                                      )
                                                                                                                      cs_51
                                                                                                              else
                                                                                                                let _ = "checkToken.fail"
                                                                                                                 in let failExp_52 =
                                                                                                                          Data.Set.Internal.Bin
                                                                                                                            1
                                                                                                                            ( Symantic.Parser.Grammar.Combinators.SomeFailure
                                                                                                                                ( case inputToken of
                                                                                                                                    (Data.Proxy.Proxy :: Data.Proxy.Proxy tok'_6989586621679080671) -> Symantic.Parser.Grammar.Combinators.FailureToken 'b'
                                                                                                                                )
                                                                                                                            )
                                                                                                                            Data.Set.Internal.Tip
                                                                                                                            Data.Set.Internal.Tip
                                                                                                                     in let (#
                                                                                                                              farInp_53,
                                                                                                                              farExp_54
                                                                                                                              #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp_42 cs_49 of
                                                                                                                                GHC.Types.LT ->
                                                                                                                                  (#
                                                                                                                                    cs_49,
                                                                                                                                    failExp_52
                                                                                                                                  #)
                                                                                                                                GHC.Types.EQ ->
                                                                                                                                  (#
                                                                                                                                    farInp_42,
                                                                                                                                    failExp_52 GHC.Base.<> farExp_43
                                                                                                                                  #)
                                                                                                                                GHC.Types.GT ->
                                                                                                                                  (#
                                                                                                                                    farInp_42,
                                                                                                                                    farExp_43
                                                                                                                                  #)
                                                                                                                         in finalRaise_18 Symantic.Parser.Grammar.Combinators.ExceptionFailure cs_49 farInp_53 farExp_54
                                                                                          else
                                                                                            let _ = "checkToken.fail"
                                                                                             in let failExp_55 =
                                                                                                      Data.Set.Internal.Bin
                                                                                                        1
                                                                                                        ( Symantic.Parser.Grammar.Combinators.SomeFailure
                                                                                                            ( case inputToken of
                                                                                                                (Data.Proxy.Proxy :: Data.Proxy.Proxy tok'_6989586621679080671) -> Symantic.Parser.Grammar.Combinators.FailureToken 'a'
                                                                                                            )
                                                                                                        )
                                                                                                        Data.Set.Internal.Tip
                                                                                                        Data.Set.Internal.Tip
                                                                                                 in let (#
                                                                                                          farInp_56,
                                                                                                          farExp_57
                                                                                                          #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp_42 inp_46 of
                                                                                                            GHC.Types.LT ->
                                                                                                              (#
                                                                                                                inp_46,
                                                                                                                failExp_55
                                                                                                              #)
                                                                                                            GHC.Types.EQ ->
                                                                                                              (#
                                                                                                                farInp_42,
                                                                                                                failExp_55 GHC.Base.<> farExp_43
                                                                                                              #)
                                                                                                            GHC.Types.GT ->
                                                                                                              (#
                                                                                                                farInp_42,
                                                                                                                farExp_43
                                                                                                              #)
                                                                                                     in finalRaise_18 Symantic.Parser.Grammar.Combinators.ExceptionFailure inp_46 farInp_56 farExp_57
                                                                              else
                                                                                let _ = "checkHorizon.newCheck.fail"
                                                                                 in let failExp_58 =
                                                                                          Data.Set.Internal.Bin
                                                                                            1
                                                                                            ( Symantic.Parser.Grammar.Combinators.SomeFailure
                                                                                                ( case inputToken of
                                                                                                    (Data.Proxy.Proxy :: Data.Proxy.Proxy tok'_6989586621679080671) -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok'_6989586621679080671 2
                                                                                                )
                                                                                            )
                                                                                            Data.Set.Internal.Tip
                                                                                            Data.Set.Internal.Tip
                                                                                     in let (#
                                                                                              farInp_59,
                                                                                              farExp_60
                                                                                              #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp_42 inp_46 of
                                                                                                GHC.Types.LT ->
                                                                                                  (#
                                                                                                    inp_46,
                                                                                                    failExp_58
                                                                                                  #)
                                                                                                GHC.Types.EQ ->
                                                                                                  (#
                                                                                                    farInp_42,
                                                                                                    failExp_58 GHC.Base.<> farExp_43
                                                                                                  #)
                                                                                                GHC.Types.GT ->
                                                                                                  (#
                                                                                                    farInp_42,
                                                                                                    farExp_43
                                                                                                  #)
                                                                                         in finalRaise_18 Symantic.Parser.Grammar.Combinators.ExceptionFailure inp_46 farInp_59 farExp_60
                                                  else
                                                    let _ = "choicesBranch.else"
                                                     in finalRaise_18 Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp_41 farInp_42 farExp_43
                                   in let _ = "pushValue"
                                       in let _ = "comment: satisfy"
                                           in let inp_61 = init_1
                                               in let readFail_62 = catchHandler_39
                                                   in let _ = "checkHorizon.newCheck: checkedHorizon=0 minHoriz=2"
                                                       in if readMore_2 (Symantic.Parser.Machine.Input.shiftRightText 1 inp_61)
                                                            then
                                                              let _ = "checkToken"
                                                               in let !(#
                                                                         c_63,
                                                                         cs_64
                                                                         #) = readNext_3 inp_61
                                                                   in if (GHC.Classes.==) 'a' c_63
                                                                        then
                                                                          let _ = "comment: satisfy"
                                                                           in let _ = "checkHorizon.oldCheck: checkedHorizon=2"
                                                                               in let _ = "checkToken"
                                                                                   in let !(#
                                                                                             c_65,
                                                                                             cs_66
                                                                                             #) = readNext_3 cs_64
                                                                                       in if (GHC.Classes.==) 'a' c_65
                                                                                            then
                                                                                              let _ = "commit"
                                                                                               in let _ = "resume"
                                                                                                   in join_34
                                                                                                        init_1
                                                                                                        Data.Set.Internal.empty
                                                                                                        ( let _ = "resume.genCode"
                                                                                                           in (GHC.Types.:) 'a' ((GHC.Types.:) 'a' GHC.Types . [])
                                                                                                        )
                                                                                                        cs_66
                                                                                            else
                                                                                              let _ = "checkToken.fail"
                                                                                               in let failExp_67 =
                                                                                                        Data.Set.Internal.Bin
                                                                                                          1
                                                                                                          ( Symantic.Parser.Grammar.Combinators.SomeFailure
                                                                                                              ( case inputToken of
                                                                                                                  (Data.Proxy.Proxy :: Data.Proxy.Proxy tok'_6989586621679080671) -> Symantic.Parser.Grammar.Combinators.FailureToken 'a'
                                                                                                              )
                                                                                                          )
                                                                                                          Data.Set.Internal.Tip
                                                                                                          Data.Set.Internal.Tip
                                                                                                   in let (#
                                                                                                            farInp_68,
                                                                                                            farExp_69
                                                                                                            #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init_1 cs_64 of
                                                                                                              GHC.Types.LT ->
                                                                                                                (#
                                                                                                                  cs_64,
                                                                                                                  failExp_67
                                                                                                                #)
                                                                                                              GHC.Types.EQ ->
                                                                                                                (#
                                                                                                                  init_1,
                                                                                                                  failExp_67 GHC.Base.<> Data.Set.Internal.empty
                                                                                                                #)
                                                                                                              GHC.Types.GT ->
                                                                                                                (#
                                                                                                                  init_1,
                                                                                                                  Data.Set.Internal.empty
                                                                                                                #)
                                                                                                       in readFail_62 Symantic.Parser.Grammar.Combinators.ExceptionFailure cs_64 farInp_68 farExp_69
                                                                        else
                                                                          let _ = "checkToken.fail"
                                                                           in let failExp_70 =
                                                                                    Data.Set.Internal.Bin
                                                                                      1
                                                                                      ( Symantic.Parser.Grammar.Combinators.SomeFailure
                                                                                          ( case inputToken of
                                                                                              (Data.Proxy.Proxy :: Data.Proxy.Proxy tok'_6989586621679080671) -> Symantic.Parser.Grammar.Combinators.FailureToken 'a'
                                                                                          )
                                                                                      )
                                                                                      Data.Set.Internal.Tip
                                                                                      Data.Set.Internal.Tip
                                                                               in let (#
                                                                                        farInp_71,
                                                                                        farExp_72
                                                                                        #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init_1 inp_61 of
                                                                                          GHC.Types.LT ->
                                                                                            (#
                                                                                              inp_61,
                                                                                              failExp_70
                                                                                            #)
                                                                                          GHC.Types.EQ ->
                                                                                            (#
                                                                                              init_1,
                                                                                              failExp_70 GHC.Base.<> Data.Set.Internal.empty
                                                                                            #)
                                                                                          GHC.Types.GT ->
                                                                                            (#
                                                                                              init_1,
                                                                                              Data.Set.Internal.empty
                                                                                            #)
                                                                                   in readFail_62 Symantic.Parser.Grammar.Combinators.ExceptionFailure inp_61 farInp_71 farExp_72
                                                            else
                                                              let _ = "checkHorizon.newCheck.fail"
                                                               in let failExp_73 =
                                                                        Data.Set.Internal.Bin
                                                                          1
                                                                          ( Symantic.Parser.Grammar.Combinators.SomeFailure
                                                                              ( case inputToken of
                                                                                  (Data.Proxy.Proxy :: Data.Proxy.Proxy tok'_6989586621679080671) -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok'_6989586621679080671 2
                                                                              )
                                                                          )
                                                                          Data.Set.Internal.Tip
                                                                          Data.Set.Internal.Tip
                                                                   in let (#
                                                                            farInp_74,
                                                                            farExp_75
                                                                            #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init_1 inp_61 of
                                                                              GHC.Types.LT ->
                                                                                (#
                                                                                  inp_61,
                                                                                  failExp_73
                                                                                #)
                                                                              GHC.Types.EQ ->
                                                                                (#
                                                                                  init_1,
                                                                                  failExp_73 GHC.Base.<> Data.Set.Internal.empty
                                                                                #)
                                                                              GHC.Types.GT ->
                                                                                (#
                                                                                  init_1,
                                                                                  Data.Set.Internal.empty
                                                                                #)
                                                                       in readFail_62 Symantic.Parser.Grammar.Combinators.ExceptionFailure inp_61 farInp_74 farExp_75
        )