\(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 name_34 = \(!callReturn_35) (!callInput_36) (!callCatchStackByLabel_37) ->
                        let _ = "catch ExceptionFailure"
                         in let catchHandler_38 (!_exn_39) (!failInp_40) (!farInp_41) (!farExp_42) =
                                  let _ = "catch.ko ExceptionFailure"
                                   in let _ = "loadInput"
                                       in let _ = "checkHorizon.noCheck"
                                           in Data.Map.Strict.Internal.findWithDefault finalRaise_18 Symantic.Parser.Grammar.Combinators.ExceptionFailure callCatchStackByLabel_37 Symantic.Parser.Grammar.Combinators.ExceptionFailure callInput_36 farInp_41 farExp_42
                             in let _ = "pushValue"
                                 in let _ = "comment: satisfy"
                                     in let inp_43 = callInput_36
                                         in let readFail_44 = catchHandler_38
                                             in let _ = "checkHorizon.newCheck: checkedHorizon=0 minHoriz=4"
                                                 in if readMore_2 (Symantic.Parser.Machine.Input.shiftRightText 3 inp_43)
                                                      then
                                                        let _ = "checkToken"
                                                         in let !(#
                                                                   c_45,
                                                                   cs_46
                                                                   #) = readNext_3 inp_43
                                                             in if (GHC.Classes.==) 'a' c_45
                                                                  then
                                                                    let _ = "comment: satisfy"
                                                                     in let _ = "checkHorizon.oldCheck: checkedHorizon=4"
                                                                         in let _ = "checkToken"
                                                                             in let !(#
                                                                                       c_47,
                                                                                       cs_48
                                                                                       #) = readNext_3 cs_46
                                                                                 in if (GHC.Classes.==) 'b' c_47
                                                                                      then
                                                                                        let _ = "comment: satisfy"
                                                                                         in let _ = "checkHorizon.oldCheck: checkedHorizon=3"
                                                                                             in let _ = "checkToken"
                                                                                                 in let !(#
                                                                                                           c_49,
                                                                                                           cs_50
                                                                                                           #) = readNext_3 cs_48
                                                                                                     in if (GHC.Classes.==) 'c' c_49
                                                                                                          then
                                                                                                            let _ = "comment: satisfy"
                                                                                                             in let _ = "checkHorizon.oldCheck: checkedHorizon=2"
                                                                                                                 in let _ = "checkToken"
                                                                                                                     in let !(#
                                                                                                                               c_51,
                                                                                                                               cs_52
                                                                                                                               #) = readNext_3 cs_50
                                                                                                                         in if (GHC.Classes.==) 'd' c_51
                                                                                                                              then
                                                                                                                                let _ = "commit"
                                                                                                                                 in let _ = "resume"
                                                                                                                                     in callReturn_35
                                                                                                                                          init_1
                                                                                                                                          Data.Set.Internal.empty
                                                                                                                                          ( let _ = "resume.genCode"
                                                                                                                                             in (GHC.Types.:) 'a' ((GHC.Types.:) 'b' ((GHC.Types.:) 'c' ((GHC.Types.:) 'd' GHC.Types . [])))
                                                                                                                                          )
                                                                                                                                          cs_52
                                                                                                                              else
                                                                                                                                let _ = "checkToken.fail"
                                                                                                                                 in let failExp_53 =
                                                                                                                                          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_54,
                                                                                                                                              farExp_55
                                                                                                                                              #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init_1 cs_50 of
                                                                                                                                                GHC.Types.LT ->
                                                                                                                                                  (#
                                                                                                                                                    cs_50,
                                                                                                                                                    failExp_53
                                                                                                                                                  #)
                                                                                                                                                GHC.Types.EQ ->
                                                                                                                                                  (#
                                                                                                                                                    init_1,
                                                                                                                                                    failExp_53 GHC.Base.<> Data.Set.Internal.empty
                                                                                                                                                  #)
                                                                                                                                                GHC.Types.GT ->
                                                                                                                                                  (#
                                                                                                                                                    init_1,
                                                                                                                                                    Data.Set.Internal.empty
                                                                                                                                                  #)
                                                                                                                                         in readFail_44 Symantic.Parser.Grammar.Combinators.ExceptionFailure cs_50 farInp_54 farExp_55
                                                                                                          else
                                                                                                            let _ = "checkToken.fail"
                                                                                                             in let failExp_56 =
                                                                                                                      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_57,
                                                                                                                          farExp_58
                                                                                                                          #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init_1 cs_48 of
                                                                                                                            GHC.Types.LT ->
                                                                                                                              (#
                                                                                                                                cs_48,
                                                                                                                                failExp_56
                                                                                                                              #)
                                                                                                                            GHC.Types.EQ ->
                                                                                                                              (#
                                                                                                                                init_1,
                                                                                                                                failExp_56 GHC.Base.<> Data.Set.Internal.empty
                                                                                                                              #)
                                                                                                                            GHC.Types.GT ->
                                                                                                                              (#
                                                                                                                                init_1,
                                                                                                                                Data.Set.Internal.empty
                                                                                                                              #)
                                                                                                                     in readFail_44 Symantic.Parser.Grammar.Combinators.ExceptionFailure cs_48 farInp_57 farExp_58
                                                                                      else
                                                                                        let _ = "checkToken.fail"
                                                                                         in let failExp_59 =
                                                                                                  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_60,
                                                                                                      farExp_61
                                                                                                      #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init_1 cs_46 of
                                                                                                        GHC.Types.LT ->
                                                                                                          (#
                                                                                                            cs_46,
                                                                                                            failExp_59
                                                                                                          #)
                                                                                                        GHC.Types.EQ ->
                                                                                                          (#
                                                                                                            init_1,
                                                                                                            failExp_59 GHC.Base.<> Data.Set.Internal.empty
                                                                                                          #)
                                                                                                        GHC.Types.GT ->
                                                                                                          (#
                                                                                                            init_1,
                                                                                                            Data.Set.Internal.empty
                                                                                                          #)
                                                                                                 in readFail_44 Symantic.Parser.Grammar.Combinators.ExceptionFailure cs_46 farInp_60 farExp_61
                                                                  else
                                                                    let _ = "checkToken.fail"
                                                                     in let failExp_62 =
                                                                              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_63,
                                                                                  farExp_64
                                                                                  #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init_1 inp_43 of
                                                                                    GHC.Types.LT ->
                                                                                      (#
                                                                                        inp_43,
                                                                                        failExp_62
                                                                                      #)
                                                                                    GHC.Types.EQ ->
                                                                                      (#
                                                                                        init_1,
                                                                                        failExp_62 GHC.Base.<> Data.Set.Internal.empty
                                                                                      #)
                                                                                    GHC.Types.GT ->
                                                                                      (#
                                                                                        init_1,
                                                                                        Data.Set.Internal.empty
                                                                                      #)
                                                                             in readFail_44 Symantic.Parser.Grammar.Combinators.ExceptionFailure inp_43 farInp_63 farExp_64
                                                      else
                                                        let _ = "checkHorizon.newCheck.fail"
                                                         in let failExp_65 =
                                                                  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 4
                                                                        )
                                                                    )
                                                                    Data.Set.Internal.Tip
                                                                    Data.Set.Internal.Tip
                                                             in let (#
                                                                      farInp_66,
                                                                      farExp_67
                                                                      #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init_1 inp_43 of
                                                                        GHC.Types.LT ->
                                                                          (#
                                                                            inp_43,
                                                                            failExp_65
                                                                          #)
                                                                        GHC.Types.EQ ->
                                                                          (#
                                                                            init_1,
                                                                            failExp_65 GHC.Base.<> Data.Set.Internal.empty
                                                                          #)
                                                                        GHC.Types.GT ->
                                                                          (#
                                                                            init_1,
                                                                            Data.Set.Internal.empty
                                                                          #)
                                                                 in readFail_44 Symantic.Parser.Grammar.Combinators.ExceptionFailure inp_43 farInp_66 farExp_67
                   in let _ = "pushValue"
                       in name_34
                            ( let _ = "suspend"
                               in \farInp_68 farExp_69 v_70 (!inp_71) ->
                                    let _ = "pushValue"
                                     in do
                                          let dupv_72 = \x_73 -> x_73
                                          reg_74 <- GHC.STRef.newSTRef dupv_72
                                          let _ = "iter"
                                           in let catchHandler_75 loopInput_76 (!_exn_77) (!failInp_78) (!farInp_79) (!farExp_80) =
                                                    let _ = "pushInput"
                                                     in if ( \( Data.Text.Internal.Text
                                                                  _
                                                                  i_81
                                                                  _
                                                                )
                                                              ( Data.Text.Internal.Text
                                                                  _
                                                                  j_82
                                                                  _
                                                                ) -> i_81 GHC.Classes.== j_82
                                                           )
                                                          loopInput_76
                                                          failInp_78
                                                          then
                                                            let _ = "choicesBranch.then"
                                                             in do
                                                                  sr_83 <- GHC.STRef.readSTRef reg_74
                                                                  let _ = "pushValue"
                                                                   in let join_84 = \farInp_85 farExp_86 v_87 (!inp_88) ->
                                                                            let _ = "resume"
                                                                             in finalRet_13
                                                                                  farInp_85
                                                                                  farExp_86
                                                                                  ( let _ = "resume.genCode"
                                                                                     in GHC.Show.show ((GHC.Types.:) v_70 (sr_83 GHC.Types . []))
                                                                                  )
                                                                                  inp_88
                                                                       in let _ = "catch ExceptionFailure"
                                                                           in let catchHandler_89 (!_exn_90) (!failInp_91) (!farInp_92) (!farExp_93) =
                                                                                    let _ = "catch.ko ExceptionFailure"
                                                                                     in let _ = "pushInput"
                                                                                         in if ( \( Data.Text.Internal.Text
                                                                                                      _
                                                                                                      i_94
                                                                                                      _
                                                                                                    )
                                                                                                  ( Data.Text.Internal.Text
                                                                                                      _
                                                                                                      j_95
                                                                                                      _
                                                                                                    ) -> i_94 GHC.Classes.== j_95
                                                                                               )
                                                                                              failInp_78
                                                                                              failInp_91
                                                                                              then
                                                                                                let _ = "choicesBranch.then"
                                                                                                 in let _ = "comment: eof.fail"
                                                                                                     in let failExp_96 = Data.Set.Internal.Bin 1 (Symantic.Parser.Grammar.Combinators.SomeFailure Symantic.Parser.Grammar.Combinators.FailureEnd) Data.Set.Internal.Tip Data.Set.Internal.Tip
                                                                                                         in let (#
                                                                                                                  farInp_97,
                                                                                                                  farExp_98
                                                                                                                  #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp_92 failInp_91 of
                                                                                                                    GHC.Types.LT ->
                                                                                                                      (#
                                                                                                                        failInp_91,
                                                                                                                        failExp_96
                                                                                                                      #)
                                                                                                                    GHC.Types.EQ ->
                                                                                                                      (#
                                                                                                                        farInp_92,
                                                                                                                        failExp_96 GHC.Base.<> farExp_93
                                                                                                                      #)
                                                                                                                    GHC.Types.GT ->
                                                                                                                      (#
                                                                                                                        farInp_92,
                                                                                                                        farExp_93
                                                                                                                      #)
                                                                                                             in finalRaise_18 Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp_91 farInp_97 farExp_98
                                                                                              else
                                                                                                let _ = "choicesBranch.else"
                                                                                                 in finalRaise_18 Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp_91 farInp_92 farExp_93
                                                                               in let _ = "comment: negLook"
                                                                                   in let _ = "catch ExceptionFailure"
                                                                                       in let catchHandler_99 (!_exn_100) (!failInp_101) (!farInp_102) (!farExp_103) =
                                                                                                let _ = "catch.ko ExceptionFailure"
                                                                                                 in let _ = "comment: negLook.reset"
                                                                                                     in let _ = "loadInput"
                                                                                                         in let _ = "checkHorizon.noCheck"
                                                                                                             in let _ = "pushValue"
                                                                                                                 in let _ = "commit"
                                                                                                                     in let _ = "resume"
                                                                                                                         in join_84
                                                                                                                              farInp_102
                                                                                                                              farExp_103
                                                                                                                              ( let _ = "resume.genCode"
                                                                                                                                 in GHC.Tuple . ()
                                                                                                                              )
                                                                                                                              failInp_78
                                                                                           in let _ = "comment: negLook.ahead"
                                                                                               in let _ = "pushInput"
                                                                                                   in let _ = "comment: satisfy"
                                                                                                       in let inp_104 = failInp_78
                                                                                                           in let readFail_105 = catchHandler_99
                                                                                                               in let _ = "checkHorizon.newCheck: checkedHorizon=0 minHoriz=1"
                                                                                                                   in if readMore_2 inp_104
                                                                                                                        then
                                                                                                                          let _ = "checkToken"
                                                                                                                           in let !(#
                                                                                                                                     c_106,
                                                                                                                                     cs_107
                                                                                                                                     #) = readNext_3 inp_104
                                                                                                                               in let _ = "popValue"
                                                                                                                                   in let _ = "commit"
                                                                                                                                       in let _ = "loadInput"
                                                                                                                                           in let _ = "checkHorizon.noCheck"
                                                                                                                                               in catchHandler_89 Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp_78 farInp_79 farExp_80
                                                                                                                        else
                                                                                                                          let _ = "checkHorizon.newCheck.fail"
                                                                                                                           in let failExp_108 =
                                                                                                                                    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 1
                                                                                                                                          )
                                                                                                                                      )
                                                                                                                                      Data.Set.Internal.Tip
                                                                                                                                      Data.Set.Internal.Tip
                                                                                                                               in let (#
                                                                                                                                        farInp_109,
                                                                                                                                        farExp_110
                                                                                                                                        #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp_79 inp_104 of
                                                                                                                                          GHC.Types.LT ->
                                                                                                                                            (#
                                                                                                                                              inp_104,
                                                                                                                                              failExp_108
                                                                                                                                            #)
                                                                                                                                          GHC.Types.EQ ->
                                                                                                                                            (#
                                                                                                                                              farInp_79,
                                                                                                                                              failExp_108 GHC.Base.<> farExp_80
                                                                                                                                            #)
                                                                                                                                          GHC.Types.GT ->
                                                                                                                                            (#
                                                                                                                                              farInp_79,
                                                                                                                                              farExp_80
                                                                                                                                            #)
                                                                                                                                   in readFail_105 Symantic.Parser.Grammar.Combinators.ExceptionFailure inp_104 farInp_109 farExp_110
                                                          else
                                                            let _ = "choicesBranch.else"
                                                             in finalRaise_18 Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp_78 farInp_79 farExp_80
                                                  loop_111 = \_callReturn_112 callInput_113 callCatchStackByLabel_114 ->
                                                    let _ = "pushValue"
                                                     in name_34
                                                          ( let _ = "suspend"
                                                             in \farInp_115 farExp_116 v_117 (!inp_118) ->
                                                                  let _ = "pushValue"
                                                                   in do
                                                                        sr_119 <- GHC.STRef.readSTRef reg_74
                                                                        do
                                                                          let dupv_120 = \x_121 -> sr_119 ((GHC.Types.:) v_117 x_121)
                                                                          GHC.STRef.writeSTRef reg_74 dupv_120
                                                                          let _ = "jump"
                                                                           in loop_111 (GHC.Err.error "invalid return") inp_118 (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure (catchHandler_75 callInput_113) Data.Map.Internal.Tip Data.Map.Internal.Tip)
                                                          )
                                                          callInput_113
                                                          (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure (catchHandler_75 callInput_113) Data.Map.Internal.Tip Data.Map.Internal.Tip)
                                               in let _ = "jump"
                                                   in loop_111 finalRet_13 inp_71 Data.Map.Internal.Tip
                            )
                            init_1
                            Data.Map.Internal.Tip
        )