\(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 _ = "catch ExceptionFailure"
                                                         in let catchHandler_46 (!_exn_47) (!failInp_48) (!farInp_49) (!farExp_50) =
                                                                  let _ = "catch.ko ExceptionFailure"
                                                                   in let _ = "loadInput"
                                                                       in let _ = "checkHorizon.noCheck"
                                                                           in finalRaise_18 Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp_41 farInp_49 farExp_50
                                                             in let _ = "pushValue"
                                                                 in let _ = "comment: satisfy"
                                                                     in let inp_51 = failInp_41
                                                                         in let readFail_52 = catchHandler_46
                                                                             in let _ = "checkHorizon.newCheck: checkedHorizon=0 minHoriz=2"
                                                                                 in if readMore_2 (Symantic.Parser.Machine.Input.shiftRightText 1 inp_51)
                                                                                      then
                                                                                        let _ = "checkToken"
                                                                                         in let !(#
                                                                                                   c_53,
                                                                                                   cs_54
                                                                                                   #) = readNext_3 inp_51
                                                                                             in if (GHC.Classes.==) 'd' c_53
                                                                                                  then
                                                                                                    let _ = "comment: satisfy"
                                                                                                     in let _ = "checkHorizon.oldCheck: checkedHorizon=2"
                                                                                                         in let _ = "checkToken"
                                                                                                             in let !(#
                                                                                                                       c_55,
                                                                                                                       cs_56
                                                                                                                       #) = readNext_3 cs_54
                                                                                                                 in if (GHC.Classes.==) 'e' c_55
                                                                                                                      then
                                                                                                                        let _ = "commit"
                                                                                                                         in let _ = "resume"
                                                                                                                             in join_34
                                                                                                                                  farInp_42
                                                                                                                                  farExp_43
                                                                                                                                  ( let _ = "resume.genCode"
                                                                                                                                     in (GHC.Types.:) 'd' ((GHC.Types.:) 'e' GHC.Types . [])
                                                                                                                                  )
                                                                                                                                  cs_56
                                                                                                                      else
                                                                                                                        let _ = "checkToken.fail"
                                                                                                                         in let failExp_57 =
                                                                                                                                  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 'e'
                                                                                                                                        )
                                                                                                                                    )
                                                                                                                                    Data.Set.Internal.Tip
                                                                                                                                    Data.Set.Internal.Tip
                                                                                                                             in let (#
                                                                                                                                      farInp_58,
                                                                                                                                      farExp_59
                                                                                                                                      #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp_42 cs_54 of
                                                                                                                                        GHC.Types.LT ->
                                                                                                                                          (#
                                                                                                                                            cs_54,
                                                                                                                                            failExp_57
                                                                                                                                          #)
                                                                                                                                        GHC.Types.EQ ->
                                                                                                                                          (#
                                                                                                                                            farInp_42,
                                                                                                                                            failExp_57 GHC.Base.<> farExp_43
                                                                                                                                          #)
                                                                                                                                        GHC.Types.GT ->
                                                                                                                                          (#
                                                                                                                                            farInp_42,
                                                                                                                                            farExp_43
                                                                                                                                          #)
                                                                                                                                 in readFail_52 Symantic.Parser.Grammar.Combinators.ExceptionFailure cs_54 farInp_58 farExp_59
                                                                                                  else
                                                                                                    let _ = "checkToken.fail"
                                                                                                     in let failExp_60 =
                                                                                                              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 'd'
                                                                                                                    )
                                                                                                                )
                                                                                                                Data.Set.Internal.Tip
                                                                                                                Data.Set.Internal.Tip
                                                                                                         in let (#
                                                                                                                  farInp_61,
                                                                                                                  farExp_62
                                                                                                                  #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp_42 inp_51 of
                                                                                                                    GHC.Types.LT ->
                                                                                                                      (#
                                                                                                                        inp_51,
                                                                                                                        failExp_60
                                                                                                                      #)
                                                                                                                    GHC.Types.EQ ->
                                                                                                                      (#
                                                                                                                        farInp_42,
                                                                                                                        failExp_60 GHC.Base.<> farExp_43
                                                                                                                      #)
                                                                                                                    GHC.Types.GT ->
                                                                                                                      (#
                                                                                                                        farInp_42,
                                                                                                                        farExp_43
                                                                                                                      #)
                                                                                                             in readFail_52 Symantic.Parser.Grammar.Combinators.ExceptionFailure inp_51 farInp_61 farExp_62
                                                                                      else
                                                                                        let _ = "checkHorizon.newCheck.fail"
                                                                                         in let failExp_63 =
                                                                                                  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_64,
                                                                                                      farExp_65
                                                                                                      #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp_42 inp_51 of
                                                                                                        GHC.Types.LT ->
                                                                                                          (#
                                                                                                            inp_51,
                                                                                                            failExp_63
                                                                                                          #)
                                                                                                        GHC.Types.EQ ->
                                                                                                          (#
                                                                                                            farInp_42,
                                                                                                            failExp_63 GHC.Base.<> farExp_43
                                                                                                          #)
                                                                                                        GHC.Types.GT ->
                                                                                                          (#
                                                                                                            farInp_42,
                                                                                                            farExp_43
                                                                                                          #)
                                                                                                 in readFail_52 Symantic.Parser.Grammar.Combinators.ExceptionFailure inp_51 farInp_64 farExp_65
                                                  else
                                                    let _ = "choicesBranch.else"
                                                     in finalRaise_18 Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp_41 farInp_42 farExp_43
                                   in let _ = "catch ExceptionFailure"
                                       in let catchHandler_66 (!_exn_67) (!failInp_68) (!farInp_69) (!farExp_70) =
                                                let _ = "catch.ko ExceptionFailure"
                                                 in let _ = "loadInput"
                                                     in let _ = "checkHorizon.noCheck"
                                                         in catchHandler_39 Symantic.Parser.Grammar.Combinators.ExceptionFailure init_1 farInp_69 farExp_70
                                           in let _ = "pushValue"
                                               in let _ = "comment: satisfy"
                                                   in let inp_71 = init_1
                                                       in let readFail_72 = catchHandler_66
                                                           in let _ = "checkHorizon.newCheck: checkedHorizon=0 minHoriz=3"
                                                               in if readMore_2 (Symantic.Parser.Machine.Input.shiftRightText 2 inp_71)
                                                                    then
                                                                      let _ = "checkToken"
                                                                       in let !(#
                                                                                 c_73,
                                                                                 cs_74
                                                                                 #) = readNext_3 inp_71
                                                                           in if (GHC.Classes.==) 'a' c_73
                                                                                then
                                                                                  let _ = "comment: satisfy"
                                                                                   in let _ = "checkHorizon.oldCheck: checkedHorizon=3"
                                                                                       in let _ = "checkToken"
                                                                                           in let !(#
                                                                                                     c_75,
                                                                                                     cs_76
                                                                                                     #) = readNext_3 cs_74
                                                                                               in if (GHC.Classes.==) 'b' c_75
                                                                                                    then
                                                                                                      let _ = "comment: satisfy"
                                                                                                       in let _ = "checkHorizon.oldCheck: checkedHorizon=2"
                                                                                                           in let _ = "checkToken"
                                                                                                               in let !(#
                                                                                                                         c_77,
                                                                                                                         cs_78
                                                                                                                         #) = readNext_3 cs_76
                                                                                                                   in if (GHC.Classes.==) 'c' c_77
                                                                                                                        then
                                                                                                                          let _ = "commit"
                                                                                                                           in let _ = "commit"
                                                                                                                               in let _ = "resume"
                                                                                                                                   in join_34
                                                                                                                                        init_1
                                                                                                                                        Data.Set.Internal.empty
                                                                                                                                        ( let _ = "resume.genCode"
                                                                                                                                           in (GHC.Types.:) 'a' ((GHC.Types.:) 'b' ((GHC.Types.:) 'c' GHC.Types . []))
                                                                                                                                        )
                                                                                                                                        cs_78
                                                                                                                        else
                                                                                                                          let _ = "checkToken.fail"
                                                                                                                           in let failExp_79 =
                                                                                                                                    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 'c'
                                                                                                                                          )
                                                                                                                                      )
                                                                                                                                      Data.Set.Internal.Tip
                                                                                                                                      Data.Set.Internal.Tip
                                                                                                                               in let (#
                                                                                                                                        farInp_80,
                                                                                                                                        farExp_81
                                                                                                                                        #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init_1 cs_76 of
                                                                                                                                          GHC.Types.LT ->
                                                                                                                                            (#
                                                                                                                                              cs_76,
                                                                                                                                              failExp_79
                                                                                                                                            #)
                                                                                                                                          GHC.Types.EQ ->
                                                                                                                                            (#
                                                                                                                                              init_1,
                                                                                                                                              failExp_79 GHC.Base.<> Data.Set.Internal.empty
                                                                                                                                            #)
                                                                                                                                          GHC.Types.GT ->
                                                                                                                                            (#
                                                                                                                                              init_1,
                                                                                                                                              Data.Set.Internal.empty
                                                                                                                                            #)
                                                                                                                                   in readFail_72 Symantic.Parser.Grammar.Combinators.ExceptionFailure cs_76 farInp_80 farExp_81
                                                                                                    else
                                                                                                      let _ = "checkToken.fail"
                                                                                                       in let failExp_82 =
                                                                                                                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_83,
                                                                                                                    farExp_84
                                                                                                                    #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init_1 cs_74 of
                                                                                                                      GHC.Types.LT ->
                                                                                                                        (#
                                                                                                                          cs_74,
                                                                                                                          failExp_82
                                                                                                                        #)
                                                                                                                      GHC.Types.EQ ->
                                                                                                                        (#
                                                                                                                          init_1,
                                                                                                                          failExp_82 GHC.Base.<> Data.Set.Internal.empty
                                                                                                                        #)
                                                                                                                      GHC.Types.GT ->
                                                                                                                        (#
                                                                                                                          init_1,
                                                                                                                          Data.Set.Internal.empty
                                                                                                                        #)
                                                                                                               in readFail_72 Symantic.Parser.Grammar.Combinators.ExceptionFailure cs_74 farInp_83 farExp_84
                                                                                else
                                                                                  let _ = "checkToken.fail"
                                                                                   in let failExp_85 =
                                                                                            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_86,
                                                                                                farExp_87
                                                                                                #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init_1 inp_71 of
                                                                                                  GHC.Types.LT ->
                                                                                                    (#
                                                                                                      inp_71,
                                                                                                      failExp_85
                                                                                                    #)
                                                                                                  GHC.Types.EQ ->
                                                                                                    (#
                                                                                                      init_1,
                                                                                                      failExp_85 GHC.Base.<> Data.Set.Internal.empty
                                                                                                    #)
                                                                                                  GHC.Types.GT ->
                                                                                                    (#
                                                                                                      init_1,
                                                                                                      Data.Set.Internal.empty
                                                                                                    #)
                                                                                           in readFail_72 Symantic.Parser.Grammar.Combinators.ExceptionFailure inp_71 farInp_86 farExp_87
                                                                    else
                                                                      let _ = "checkHorizon.newCheck.fail"
                                                                       in let failExp_88 =
                                                                                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 3
                                                                                      )
                                                                                  )
                                                                                  Data.Set.Internal.Tip
                                                                                  Data.Set.Internal.Tip
                                                                           in let (#
                                                                                    farInp_89,
                                                                                    farExp_90
                                                                                    #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init_1 inp_71 of
                                                                                      GHC.Types.LT ->
                                                                                        (#
                                                                                          inp_71,
                                                                                          failExp_88
                                                                                        #)
                                                                                      GHC.Types.EQ ->
                                                                                        (#
                                                                                          init_1,
                                                                                          failExp_88 GHC.Base.<> Data.Set.Internal.empty
                                                                                        #)
                                                                                      GHC.Types.GT ->
                                                                                        (#
                                                                                          init_1,
                                                                                          Data.Set.Internal.empty
                                                                                        #)
                                                                               in readFail_72 Symantic.Parser.Grammar.Combinators.ExceptionFailure inp_71 farInp_89 farExp_90
        )