\(input :: inp) ->
  let !(#
         init,
         readMore,
         readNext
         #) =
          let _ = "cursorOf"
           in let next
                    ( t@( Data.Text.Internal.Text
                            arr
                            off
                            unconsumed
                          )
                      ) =
                      let !( Data.Text.Unsafe.Iter
                               c
                               d
                             ) = Data.Text.Unsafe.iter t 0
                       in (#
                            c,
                            Data.Text.Internal.Text arr (off GHC.Num.+ d) (unconsumed GHC.Num.- d)
                          #)
                  more
                    ( Data.Text.Internal.Text
                        _
                        _
                        unconsumed
                      ) = unconsumed GHC.Classes.> 0
               in (# input, more, next #)
      finalRet = \_farInp _farExp v _inp -> Symantic.Parser.Machine.Generate.returnST GHC.Base.$ Data.Either.Right v
      finalRaise ::
        forall st b.
        Symantic.Parser.Machine.Generate.Catcher
          st
          inp
          b = \(!exn) _failInp (!farInp) (!farExp) ->
          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,
                  Symantic.Parser.Machine.Generate.parsingErrorException = exn,
                  Symantic.Parser.Machine.Generate.parsingErrorUnexpected =
                    if readMore farInp
                      then
                        GHC.Maybe.Just
                          ( let (#
                                  c,
                                  _
                                  #) = readNext farInp
                             in c
                          )
                      else GHC.Maybe.Nothing,
                  Symantic.Parser.Machine.Generate.parsingErrorExpecting = farExp
                }
   in GHC.ST.runST
        ( let inputToken = Data.Proxy.Proxy :: Data.Proxy.Proxy (Symantic.Parser.Machine.Input.InputToken inp)
           in let name = \(!callReturn) (!callInput) (!callCatchStackByLabel) ->
                    name
                      ( let _ = "suspend"
                         in \farInp farExp v (!inp) ->
                              let join = \farInp farExp v (!inp) ->
                                    let _ = "resume"
                                     in callReturn
                                          farInp
                                          farExp
                                          ( let _ = "resume.genCode"
                                             in v
                                          )
                                          inp
                               in let _ = "catch ExceptionFailure"
                                   in let catchHandler (!_exn) (!failInp) (!farInp) (!farExp) =
                                            let _ = "catch.ko ExceptionFailure"
                                             in if ( \( Data.Text.Internal.Text
                                                          _
                                                          i
                                                          _
                                                        )
                                                      ( Data.Text.Internal.Text
                                                          _
                                                          j
                                                          _
                                                        ) -> i GHC.Classes.== j
                                                   )
                                                  inp
                                                  failInp
                                                  then
                                                    let _ = "choicesBranch.then"
                                                     in name
                                                          ( let _ = "suspend"
                                                             in \farInp farExp v (!inp) ->
                                                                  let _ = "resume"
                                                                   in join
                                                                        farInp
                                                                        farExp
                                                                        ( let _ = "resume.genCode"
                                                                           in v
                                                                        )
                                                                        inp
                                                          )
                                                          failInp
                                                          Data.Map.Internal.Tip
                                                  else
                                                    let _ = "choicesBranch.else"
                                                     in Data.Map.Strict.Internal.findWithDefault finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure callCatchStackByLabel Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp
                                       in name
                                            ( let _ = "suspend"
                                               in \farInp farExp v (!inp) ->
                                                    let _ = "resume"
                                                     in join
                                                          farInp
                                                          farExp
                                                          ( let _ = "resume.genCode"
                                                             in GHC.Tuple . ()
                                                          )
                                                          inp
                                            )
                                            inp
                                            (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure catchHandler Data.Map.Internal.Tip Data.Map.Internal.Tip)
                      )
                      callInput
                      (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure (Data.Map.Strict.Internal.findWithDefault finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure callCatchStackByLabel) Data.Map.Internal.Tip Data.Map.Internal.Tip)
                  name = \(!callReturn) (!callInput) (!callCatchStackByLabel) ->
                    name
                      ( let _ = "suspend"
                         in \farInp farExp v (!inp) -> do
                              let dupv = \x -> x
                              reg <- GHC.STRef.newSTRef dupv
                              let _ = "iter"
                               in let catchHandler loopInput (!_exn) (!failInp) (!farInp) (!farExp) =
                                        if ( \( Data.Text.Internal.Text
                                                  _
                                                  i
                                                  _
                                                )
                                              ( Data.Text.Internal.Text
                                                  _
                                                  j
                                                  _
                                                ) -> i GHC.Classes.== j
                                           )
                                          loopInput
                                          failInp
                                          then
                                            let _ = "choicesBranch.then"
                                             in do
                                                  sr <- GHC.STRef.readSTRef reg
                                                  name
                                                    ( let _ = "suspend"
                                                       in \farInp farExp v (!inp) ->
                                                            name
                                                              ( let _ = "suspend"
                                                                 in \farInp farExp v (!inp) ->
                                                                      let _ = "resume"
                                                                       in callReturn
                                                                            farInp
                                                                            farExp
                                                                            ( let _ = "resume.genCode"
                                                                               in v
                                                                            )
                                                                            inp
                                                              )
                                                              inp
                                                              Data.Map.Internal.Tip
                                                    )
                                                    failInp
                                                    Data.Map.Internal.Tip
                                          else
                                            let _ = "choicesBranch.else"
                                             in Data.Map.Strict.Internal.findWithDefault finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure callCatchStackByLabel Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp
                                      loop = \_callReturn callInput callCatchStackByLabel ->
                                        let readFail = catchHandler callInput
                                         in if readMore (Symantic.Parser.Machine.Input.shiftRightText 1 callInput)
                                              then
                                                let !(#
                                                       c,
                                                       cs
                                                       #) = readNext callInput
                                                 in if (GHC.Classes.==) '!' c
                                                      then
                                                        name
                                                          ( let _ = "suspend"
                                                             in \farInp farExp v (!inp) ->
                                                                  name
                                                                    ( let _ = "suspend"
                                                                       in \farInp farExp v (!inp) -> do
                                                                            sr <- GHC.STRef.readSTRef reg
                                                                            do
                                                                              let dupv = sr
                                                                              GHC.STRef.writeSTRef reg dupv
                                                                              let _ = "jump"
                                                                               in loop (GHC.Err.error "invalid return") inp (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure readFail Data.Map.Internal.Tip Data.Map.Internal.Tip)
                                                                    )
                                                                    inp
                                                                    (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure readFail Data.Map.Internal.Tip Data.Map.Internal.Tip)
                                                          )
                                                          cs
                                                          (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure readFail Data.Map.Internal.Tip Data.Map.Internal.Tip)
                                                      else
                                                        let _ = "checkToken.else"
                                                         in let failExp =
                                                                  Data.Set.Internal.Bin
                                                                    1
                                                                    ( Symantic.Parser.Grammar.Combinators.SomeFailure
                                                                        ( case inputToken of
                                                                            (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken '!'
                                                                        )
                                                                    )
                                                                    Data.Set.Internal.Tip
                                                                    Data.Set.Internal.Tip
                                                             in let (#
                                                                      farInp,
                                                                      farExp
                                                                      #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp callInput of
                                                                        GHC.Types.LT ->
                                                                          (#
                                                                            callInput,
                                                                            failExp
                                                                          #)
                                                                        GHC.Types.EQ ->
                                                                          (#
                                                                            farInp,
                                                                            failExp GHC.Base.<> farExp
                                                                          #)
                                                                        GHC.Types.GT ->
                                                                          (#
                                                                            farInp,
                                                                            farExp
                                                                          #)
                                                                 in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure callInput farInp farExp
                                              else
                                                let _ = "checkHorizon.else"
                                                 in let failExp =
                                                          Data.Set.Internal.Bin
                                                            1
                                                            ( Symantic.Parser.Grammar.Combinators.SomeFailure
                                                                ( case inputToken of
                                                                    (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 2
                                                                )
                                                            )
                                                            Data.Set.Internal.Tip
                                                            Data.Set.Internal.Tip
                                                     in let (#
                                                              farInp,
                                                              farExp
                                                              #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp callInput of
                                                                GHC.Types.LT ->
                                                                  (#
                                                                    callInput,
                                                                    failExp
                                                                  #)
                                                                GHC.Types.EQ ->
                                                                  (#
                                                                    farInp,
                                                                    failExp GHC.Base.<> farExp
                                                                  #)
                                                                GHC.Types.GT ->
                                                                  (#
                                                                    farInp,
                                                                    farExp
                                                                  #)
                                                         in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure callInput farInp farExp
                                   in let _ = "jump"
                                       in loop callReturn inp (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure (Data.Map.Strict.Internal.findWithDefault finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure callCatchStackByLabel) Data.Map.Internal.Tip Data.Map.Internal.Tip)
                      )
                      callInput
                      (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure (Data.Map.Strict.Internal.findWithDefault finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure callCatchStackByLabel) Data.Map.Internal.Tip Data.Map.Internal.Tip)
                  name = \(!callReturn) (!callInput) (!callCatchStackByLabel) ->
                    name
                      ( let _ = "suspend"
                         in \farInp farExp v (!inp) -> do
                              let dupv = \x -> x
                              reg <- GHC.STRef.newSTRef dupv
                              let _ = "iter"
                               in let catchHandler loopInput (!_exn) (!failInp) (!farInp) (!farExp) =
                                        if ( \( Data.Text.Internal.Text
                                                  _
                                                  i
                                                  _
                                                )
                                              ( Data.Text.Internal.Text
                                                  _
                                                  j
                                                  _
                                                ) -> i GHC.Classes.== j
                                           )
                                          loopInput
                                          failInp
                                          then
                                            let _ = "choicesBranch.then"
                                             in do
                                                  sr <- GHC.STRef.readSTRef reg
                                                  let _ = "resume"
                                                   in callReturn
                                                        farInp
                                                        farExp
                                                        ( let _ = "resume.genCode"
                                                           in GHC.Tuple . ()
                                                        )
                                                        failInp
                                          else
                                            let _ = "choicesBranch.else"
                                             in Data.Map.Strict.Internal.findWithDefault finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure callCatchStackByLabel Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp
                                      loop = \_callReturn callInput callCatchStackByLabel ->
                                        name
                                          ( let _ = "suspend"
                                             in \farInp farExp v (!inp) -> do
                                                  sr <- GHC.STRef.readSTRef reg
                                                  do
                                                    let dupv = sr
                                                    GHC.STRef.writeSTRef reg dupv
                                                    let _ = "jump"
                                                     in loop (GHC.Err.error "invalid return") inp (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure (catchHandler callInput) Data.Map.Internal.Tip Data.Map.Internal.Tip)
                                          )
                                          callInput
                                          (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure (catchHandler callInput) Data.Map.Internal.Tip Data.Map.Internal.Tip)
                                   in let _ = "jump"
                                       in loop callReturn inp (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure (Data.Map.Strict.Internal.findWithDefault finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure callCatchStackByLabel) Data.Map.Internal.Tip Data.Map.Internal.Tip)
                      )
                      callInput
                      (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure (Data.Map.Strict.Internal.findWithDefault finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure callCatchStackByLabel) Data.Map.Internal.Tip Data.Map.Internal.Tip)
                  name = \(!callReturn) (!callInput) (!callCatchStackByLabel) ->
                    let readFail = Data.Map.Strict.Internal.findWithDefault finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure callCatchStackByLabel
                     in if readMore callInput
                          then
                            let !(#
                                   c,
                                   cs
                                   #) = readNext callInput
                             in if GHC.Unicode.isSpace c
                                  then
                                    name
                                      ( let _ = "suspend"
                                         in \farInp farExp v (!inp) ->
                                              let _ = "resume"
                                               in callReturn
                                                    farInp
                                                    farExp
                                                    ( let _ = "resume.genCode"
                                                       in v
                                                    )
                                                    inp
                                      )
                                      cs
                                      Data.Map.Internal.Tip
                                  else
                                    let _ = "checkToken.else"
                                     in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure callInput init Data.Set.Internal.empty
                          else
                            let _ = "checkHorizon.else"
                             in let failExp =
                                      Data.Set.Internal.Bin
                                        1
                                        ( Symantic.Parser.Grammar.Combinators.SomeFailure
                                            ( case inputToken of
                                                (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 1
                                            )
                                        )
                                        Data.Set.Internal.Tip
                                        Data.Set.Internal.Tip
                                 in let (#
                                          farInp,
                                          farExp
                                          #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init callInput of
                                            GHC.Types.LT ->
                                              (#
                                                callInput,
                                                failExp
                                              #)
                                            GHC.Types.EQ ->
                                              (#
                                                init,
                                                failExp GHC.Base.<> Data.Set.Internal.empty
                                              #)
                                            GHC.Types.GT ->
                                              (#
                                                init,
                                                Data.Set.Internal.empty
                                              #)
                                     in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure callInput farInp farExp
                  name = \(!callReturn) (!callInput) (!callCatchStackByLabel) ->
                    let readFail = Data.Map.Strict.Internal.findWithDefault finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure callCatchStackByLabel
                     in if readMore callInput
                          then
                            let !(#
                                   c,
                                   cs
                                   #) = readNext callInput
                             in if (\t -> ('0' GHC.Classes.== t) GHC.Classes.|| (('1' GHC.Classes.== t) GHC.Classes.|| (('2' GHC.Classes.== t) GHC.Classes.|| (('3' GHC.Classes.== t) GHC.Classes.|| (('4' GHC.Classes.== t) GHC.Classes.|| (('5' GHC.Classes.== t) GHC.Classes.|| (('6' GHC.Classes.== t) GHC.Classes.|| (('7' GHC.Classes.== t) GHC.Classes.|| (('8' GHC.Classes.== t) GHC.Classes.|| (('9' GHC.Classes.== t) GHC.Classes.|| GHC.Types.False)))))))))) c
                                  then
                                    let _ = "resume"
                                     in callReturn
                                          init
                                          Data.Set.Internal.empty
                                          ( let _ = "resume.genCode"
                                             in c
                                          )
                                          cs
                                  else
                                    let _ = "checkToken.else"
                                     in let failExp =
                                              Data.Set.Internal.Bin
                                                10
                                                ( Symantic.Parser.Grammar.Combinators.SomeFailure
                                                    ( case inputToken of
                                                        (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken '3'
                                                    )
                                                )
                                                ( Data.Set.Internal.Bin
                                                    3
                                                    ( Symantic.Parser.Grammar.Combinators.SomeFailure
                                                        ( case inputToken of
                                                            (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken '1'
                                                        )
                                                    )
                                                    ( Data.Set.Internal.Bin
                                                        1
                                                        ( Symantic.Parser.Grammar.Combinators.SomeFailure
                                                            ( case inputToken of
                                                                (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken '0'
                                                            )
                                                        )
                                                        Data.Set.Internal.Tip
                                                        Data.Set.Internal.Tip
                                                    )
                                                    ( Data.Set.Internal.Bin
                                                        1
                                                        ( Symantic.Parser.Grammar.Combinators.SomeFailure
                                                            ( case inputToken of
                                                                (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken '2'
                                                            )
                                                        )
                                                        Data.Set.Internal.Tip
                                                        Data.Set.Internal.Tip
                                                    )
                                                )
                                                ( Data.Set.Internal.Bin
                                                    6
                                                    ( Symantic.Parser.Grammar.Combinators.SomeFailure
                                                        ( case inputToken of
                                                            (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken '7'
                                                        )
                                                    )
                                                    ( Data.Set.Internal.Bin
                                                        3
                                                        ( Symantic.Parser.Grammar.Combinators.SomeFailure
                                                            ( case inputToken of
                                                                (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken '5'
                                                            )
                                                        )
                                                        ( Data.Set.Internal.Bin
                                                            1
                                                            ( Symantic.Parser.Grammar.Combinators.SomeFailure
                                                                ( case inputToken of
                                                                    (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken '4'
                                                                )
                                                            )
                                                            Data.Set.Internal.Tip
                                                            Data.Set.Internal.Tip
                                                        )
                                                        ( Data.Set.Internal.Bin
                                                            1
                                                            ( Symantic.Parser.Grammar.Combinators.SomeFailure
                                                                ( case inputToken of
                                                                    (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken '6'
                                                                )
                                                            )
                                                            Data.Set.Internal.Tip
                                                            Data.Set.Internal.Tip
                                                        )
                                                    )
                                                    ( Data.Set.Internal.Bin
                                                        2
                                                        ( Symantic.Parser.Grammar.Combinators.SomeFailure
                                                            ( case inputToken of
                                                                (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken '8'
                                                            )
                                                        )
                                                        Data.Set.Internal.Tip
                                                        ( Data.Set.Internal.Bin
                                                            1
                                                            ( Symantic.Parser.Grammar.Combinators.SomeFailure
                                                                ( case inputToken of
                                                                    (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken '9'
                                                                )
                                                            )
                                                            Data.Set.Internal.Tip
                                                            Data.Set.Internal.Tip
                                                        )
                                                    )
                                                )
                                         in let (#
                                                  farInp,
                                                  farExp
                                                  #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init callInput of
                                                    GHC.Types.LT ->
                                                      (#
                                                        callInput,
                                                        failExp
                                                      #)
                                                    GHC.Types.EQ ->
                                                      (#
                                                        init,
                                                        failExp GHC.Base.<> Data.Set.Internal.empty
                                                      #)
                                                    GHC.Types.GT ->
                                                      (#
                                                        init,
                                                        Data.Set.Internal.empty
                                                      #)
                                             in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure callInput farInp farExp
                          else
                            let _ = "checkHorizon.else"
                             in let failExp =
                                      Data.Set.Internal.Bin
                                        1
                                        ( Symantic.Parser.Grammar.Combinators.SomeFailure
                                            ( case inputToken of
                                                (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 1
                                            )
                                        )
                                        Data.Set.Internal.Tip
                                        Data.Set.Internal.Tip
                                 in let (#
                                          farInp,
                                          farExp
                                          #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init callInput of
                                            GHC.Types.LT ->
                                              (#
                                                callInput,
                                                failExp
                                              #)
                                            GHC.Types.EQ ->
                                              (#
                                                init,
                                                failExp GHC.Base.<> Data.Set.Internal.empty
                                              #)
                                            GHC.Types.GT ->
                                              (#
                                                init,
                                                Data.Set.Internal.empty
                                              #)
                                     in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure callInput farInp farExp
                  name = \(!callReturn) (!callInput) (!callCatchStackByLabel) ->
                    let readFail = Data.Map.Strict.Internal.findWithDefault finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure callCatchStackByLabel
                     in if readMore (Symantic.Parser.Machine.Input.shiftRightText 1 callInput)
                          then
                            let !(#
                                   c,
                                   cs
                                   #) = readNext callInput
                             in if (GHC.Classes.==) '(' c
                                  then
                                    name
                                      ( let _ = "suspend"
                                         in \farInp farExp v (!inp) ->
                                              let _ = "resume"
                                               in callReturn
                                                    farInp
                                                    farExp
                                                    ( let _ = "resume.genCode"
                                                       in '('
                                                    )
                                                    inp
                                      )
                                      cs
                                      (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure readFail Data.Map.Internal.Tip Data.Map.Internal.Tip)
                                  else
                                    let _ = "checkToken.else"
                                     in let failExp =
                                              Data.Set.Internal.Bin
                                                1
                                                ( Symantic.Parser.Grammar.Combinators.SomeFailure
                                                    ( case inputToken of
                                                        (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken '('
                                                    )
                                                )
                                                Data.Set.Internal.Tip
                                                Data.Set.Internal.Tip
                                         in let (#
                                                  farInp,
                                                  farExp
                                                  #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init callInput of
                                                    GHC.Types.LT ->
                                                      (#
                                                        callInput,
                                                        failExp
                                                      #)
                                                    GHC.Types.EQ ->
                                                      (#
                                                        init,
                                                        failExp GHC.Base.<> Data.Set.Internal.empty
                                                      #)
                                                    GHC.Types.GT ->
                                                      (#
                                                        init,
                                                        Data.Set.Internal.empty
                                                      #)
                                             in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure callInput farInp farExp
                          else
                            let _ = "checkHorizon.else"
                             in let failExp =
                                      Data.Set.Internal.Bin
                                        1
                                        ( Symantic.Parser.Grammar.Combinators.SomeFailure
                                            ( case inputToken of
                                                (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 2
                                            )
                                        )
                                        Data.Set.Internal.Tip
                                        Data.Set.Internal.Tip
                                 in let (#
                                          farInp,
                                          farExp
                                          #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init callInput of
                                            GHC.Types.LT ->
                                              (#
                                                callInput,
                                                failExp
                                              #)
                                            GHC.Types.EQ ->
                                              (#
                                                init,
                                                failExp GHC.Base.<> Data.Set.Internal.empty
                                              #)
                                            GHC.Types.GT ->
                                              (#
                                                init,
                                                Data.Set.Internal.empty
                                              #)
                                     in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure callInput farInp farExp
                  name = \(!callReturn) (!callInput) (!callCatchStackByLabel) ->
                    let readFail = Data.Map.Strict.Internal.findWithDefault finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure callCatchStackByLabel
                     in if readMore (Symantic.Parser.Machine.Input.shiftRightText 1 callInput)
                          then
                            let !(#
                                   c,
                                   cs
                                   #) = readNext callInput
                             in if (GHC.Classes.==) ')' c
                                  then
                                    name
                                      ( let _ = "suspend"
                                         in \farInp farExp v (!inp) ->
                                              let _ = "resume"
                                               in callReturn
                                                    farInp
                                                    farExp
                                                    ( let _ = "resume.genCode"
                                                       in ')'
                                                    )
                                                    inp
                                      )
                                      cs
                                      (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure readFail Data.Map.Internal.Tip Data.Map.Internal.Tip)
                                  else
                                    let _ = "checkToken.else"
                                     in let failExp =
                                              Data.Set.Internal.Bin
                                                1
                                                ( Symantic.Parser.Grammar.Combinators.SomeFailure
                                                    ( case inputToken of
                                                        (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken ')'
                                                    )
                                                )
                                                Data.Set.Internal.Tip
                                                Data.Set.Internal.Tip
                                         in let (#
                                                  farInp,
                                                  farExp
                                                  #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init callInput of
                                                    GHC.Types.LT ->
                                                      (#
                                                        callInput,
                                                        failExp
                                                      #)
                                                    GHC.Types.EQ ->
                                                      (#
                                                        init,
                                                        failExp GHC.Base.<> Data.Set.Internal.empty
                                                      #)
                                                    GHC.Types.GT ->
                                                      (#
                                                        init,
                                                        Data.Set.Internal.empty
                                                      #)
                                             in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure callInput farInp farExp
                          else
                            let _ = "checkHorizon.else"
                             in let failExp =
                                      Data.Set.Internal.Bin
                                        1
                                        ( Symantic.Parser.Grammar.Combinators.SomeFailure
                                            ( case inputToken of
                                                (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 2
                                            )
                                        )
                                        Data.Set.Internal.Tip
                                        Data.Set.Internal.Tip
                                 in let (#
                                          farInp,
                                          farExp
                                          #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init callInput of
                                            GHC.Types.LT ->
                                              (#
                                                callInput,
                                                failExp
                                              #)
                                            GHC.Types.EQ ->
                                              (#
                                                init,
                                                failExp GHC.Base.<> Data.Set.Internal.empty
                                              #)
                                            GHC.Types.GT ->
                                              (#
                                                init,
                                                Data.Set.Internal.empty
                                              #)
                                     in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure callInput farInp farExp
                  name = \(!callReturn) (!callInput) (!callCatchStackByLabel) ->
                    let readFail = Data.Map.Strict.Internal.findWithDefault finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure callCatchStackByLabel
                     in if readMore (Symantic.Parser.Machine.Input.shiftRightText 1 callInput)
                          then
                            let !(#
                                   c,
                                   cs
                                   #) = readNext callInput
                             in if (GHC.Classes.==) ',' c
                                  then
                                    name
                                      ( let _ = "suspend"
                                         in \farInp farExp v (!inp) ->
                                              let _ = "resume"
                                               in callReturn
                                                    farInp
                                                    farExp
                                                    ( let _ = "resume.genCode"
                                                       in ','
                                                    )
                                                    inp
                                      )
                                      cs
                                      (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure readFail Data.Map.Internal.Tip Data.Map.Internal.Tip)
                                  else
                                    let _ = "checkToken.else"
                                     in let failExp =
                                              Data.Set.Internal.Bin
                                                1
                                                ( Symantic.Parser.Grammar.Combinators.SomeFailure
                                                    ( case inputToken of
                                                        (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken ','
                                                    )
                                                )
                                                Data.Set.Internal.Tip
                                                Data.Set.Internal.Tip
                                         in let (#
                                                  farInp,
                                                  farExp
                                                  #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init callInput of
                                                    GHC.Types.LT ->
                                                      (#
                                                        callInput,
                                                        failExp
                                                      #)
                                                    GHC.Types.EQ ->
                                                      (#
                                                        init,
                                                        failExp GHC.Base.<> Data.Set.Internal.empty
                                                      #)
                                                    GHC.Types.GT ->
                                                      (#
                                                        init,
                                                        Data.Set.Internal.empty
                                                      #)
                                             in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure callInput farInp farExp
                          else
                            let _ = "checkHorizon.else"
                             in let failExp =
                                      Data.Set.Internal.Bin
                                        1
                                        ( Symantic.Parser.Grammar.Combinators.SomeFailure
                                            ( case inputToken of
                                                (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 2
                                            )
                                        )
                                        Data.Set.Internal.Tip
                                        Data.Set.Internal.Tip
                                 in let (#
                                          farInp,
                                          farExp
                                          #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init callInput of
                                            GHC.Types.LT ->
                                              (#
                                                callInput,
                                                failExp
                                              #)
                                            GHC.Types.EQ ->
                                              (#
                                                init,
                                                failExp GHC.Base.<> Data.Set.Internal.empty
                                              #)
                                            GHC.Types.GT ->
                                              (#
                                                init,
                                                Data.Set.Internal.empty
                                              #)
                                     in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure callInput farInp farExp
                  name = \(!callReturn) (!callInput) (!callCatchStackByLabel) ->
                    let readFail = Data.Map.Strict.Internal.findWithDefault finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure callCatchStackByLabel
                     in if readMore (Symantic.Parser.Machine.Input.shiftRightText 1 callInput)
                          then
                            let !(#
                                   c,
                                   cs
                                   #) = readNext callInput
                             in if (GHC.Classes.==) ';' c
                                  then
                                    name
                                      ( let _ = "suspend"
                                         in \farInp farExp v (!inp) ->
                                              let _ = "resume"
                                               in callReturn
                                                    farInp
                                                    farExp
                                                    ( let _ = "resume.genCode"
                                                       in ';'
                                                    )
                                                    inp
                                      )
                                      cs
                                      (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure readFail Data.Map.Internal.Tip Data.Map.Internal.Tip)
                                  else
                                    let _ = "checkToken.else"
                                     in let failExp =
                                              Data.Set.Internal.Bin
                                                1
                                                ( Symantic.Parser.Grammar.Combinators.SomeFailure
                                                    ( case inputToken of
                                                        (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken ';'
                                                    )
                                                )
                                                Data.Set.Internal.Tip
                                                Data.Set.Internal.Tip
                                         in let (#
                                                  farInp,
                                                  farExp
                                                  #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init callInput of
                                                    GHC.Types.LT ->
                                                      (#
                                                        callInput,
                                                        failExp
                                                      #)
                                                    GHC.Types.EQ ->
                                                      (#
                                                        init,
                                                        failExp GHC.Base.<> Data.Set.Internal.empty
                                                      #)
                                                    GHC.Types.GT ->
                                                      (#
                                                        init,
                                                        Data.Set.Internal.empty
                                                      #)
                                             in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure callInput farInp farExp
                          else
                            let _ = "checkHorizon.else"
                             in let failExp =
                                      Data.Set.Internal.Bin
                                        1
                                        ( Symantic.Parser.Grammar.Combinators.SomeFailure
                                            ( case inputToken of
                                                (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 2
                                            )
                                        )
                                        Data.Set.Internal.Tip
                                        Data.Set.Internal.Tip
                                 in let (#
                                          farInp,
                                          farExp
                                          #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init callInput of
                                            GHC.Types.LT ->
                                              (#
                                                callInput,
                                                failExp
                                              #)
                                            GHC.Types.EQ ->
                                              (#
                                                init,
                                                failExp GHC.Base.<> Data.Set.Internal.empty
                                              #)
                                            GHC.Types.GT ->
                                              (#
                                                init,
                                                Data.Set.Internal.empty
                                              #)
                                     in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure callInput farInp farExp
                  name = \(!callReturn) (!callInput) (!callCatchStackByLabel) ->
                    let readFail = Data.Map.Strict.Internal.findWithDefault finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure callCatchStackByLabel
                     in if readMore (Symantic.Parser.Machine.Input.shiftRightText 3 callInput)
                          then
                            let !(#
                                   c,
                                   cs
                                   #) = readNext callInput
                             in if (GHC.Classes.==) '{' c
                                  then
                                    name
                                      ( let _ = "suspend"
                                         in \farInp farExp v (!inp) -> do
                                              let dupv = \x -> x
                                              reg <- GHC.STRef.newSTRef dupv
                                              let _ = "iter"
                                               in let catchHandler loopInput (!_exn) (!failInp) (!farInp) (!farExp) =
                                                        if ( \( Data.Text.Internal.Text
                                                                  _
                                                                  i
                                                                  _
                                                                )
                                                              ( Data.Text.Internal.Text
                                                                  _
                                                                  j
                                                                  _
                                                                ) -> i GHC.Classes.== j
                                                           )
                                                          loopInput
                                                          failInp
                                                          then
                                                            let _ = "choicesBranch.then"
                                                             in do
                                                                  sr <- GHC.STRef.readSTRef reg
                                                                  name
                                                                    ( let _ = "suspend"
                                                                       in \farInp farExp v (!inp) ->
                                                                            name
                                                                              ( let _ = "suspend"
                                                                                 in \farInp farExp v (!inp) ->
                                                                                      let readFail = readFail
                                                                                       in if readMore inp
                                                                                            then
                                                                                              let !(#
                                                                                                     c,
                                                                                                     cs
                                                                                                     #) = readNext inp
                                                                                               in if (GHC.Classes.==) '}' c
                                                                                                    then
                                                                                                      name
                                                                                                        ( let _ = "suspend"
                                                                                                           in \farInp farExp v (!inp) ->
                                                                                                                let _ = "resume"
                                                                                                                 in callReturn
                                                                                                                      farInp
                                                                                                                      farExp
                                                                                                                      ( let _ = "resume.genCode"
                                                                                                                         in v
                                                                                                                      )
                                                                                                                      inp
                                                                                                        )
                                                                                                        cs
                                                                                                        (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure readFail Data.Map.Internal.Tip Data.Map.Internal.Tip)
                                                                                                    else
                                                                                                      let _ = "checkToken.else"
                                                                                                       in let failExp =
                                                                                                                Data.Set.Internal.Bin
                                                                                                                  1
                                                                                                                  ( Symantic.Parser.Grammar.Combinators.SomeFailure
                                                                                                                      ( case inputToken of
                                                                                                                          (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken '}'
                                                                                                                      )
                                                                                                                  )
                                                                                                                  Data.Set.Internal.Tip
                                                                                                                  Data.Set.Internal.Tip
                                                                                                           in let (#
                                                                                                                    farInp,
                                                                                                                    farExp
                                                                                                                    #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp inp of
                                                                                                                      GHC.Types.LT ->
                                                                                                                        (#
                                                                                                                          inp,
                                                                                                                          failExp
                                                                                                                        #)
                                                                                                                      GHC.Types.EQ ->
                                                                                                                        (#
                                                                                                                          farInp,
                                                                                                                          failExp GHC.Base.<> farExp
                                                                                                                        #)
                                                                                                                      GHC.Types.GT ->
                                                                                                                        (#
                                                                                                                          farInp,
                                                                                                                          farExp
                                                                                                                        #)
                                                                                                               in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp
                                                                                            else
                                                                                              let _ = "checkHorizon.else"
                                                                                               in let failExp =
                                                                                                        Data.Set.Internal.Bin
                                                                                                          1
                                                                                                          ( Symantic.Parser.Grammar.Combinators.SomeFailure
                                                                                                              ( case inputToken of
                                                                                                                  (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 1
                                                                                                              )
                                                                                                          )
                                                                                                          Data.Set.Internal.Tip
                                                                                                          Data.Set.Internal.Tip
                                                                                                   in let (#
                                                                                                            farInp,
                                                                                                            farExp
                                                                                                            #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp inp of
                                                                                                              GHC.Types.LT ->
                                                                                                                (#
                                                                                                                  inp,
                                                                                                                  failExp
                                                                                                                #)
                                                                                                              GHC.Types.EQ ->
                                                                                                                (#
                                                                                                                  farInp,
                                                                                                                  failExp GHC.Base.<> farExp
                                                                                                                #)
                                                                                                              GHC.Types.GT ->
                                                                                                                (#
                                                                                                                  farInp,
                                                                                                                  farExp
                                                                                                                #)
                                                                                                       in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp
                                                                              )
                                                                              inp
                                                                              Data.Map.Internal.Tip
                                                                    )
                                                                    failInp
                                                                    Data.Map.Internal.Tip
                                                          else
                                                            let _ = "choicesBranch.else"
                                                             in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp
                                                      loop = \_callReturn callInput callCatchStackByLabel ->
                                                        let join = \farInp farExp v (!inp) -> do
                                                              sr <- GHC.STRef.readSTRef reg
                                                              do
                                                                let dupv = sr
                                                                GHC.STRef.writeSTRef reg dupv
                                                                let _ = "jump"
                                                                 in loop (GHC.Err.error "invalid return") inp (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure (catchHandler callInput) Data.Map.Internal.Tip Data.Map.Internal.Tip)
                                                         in let _ = "catch ExceptionFailure"
                                                             in let catchHandler (!_exn) (!failInp) (!farInp) (!farExp) =
                                                                      let _ = "catch.ko ExceptionFailure"
                                                                       in if ( \( Data.Text.Internal.Text
                                                                                    _
                                                                                    i
                                                                                    _
                                                                                  )
                                                                                ( Data.Text.Internal.Text
                                                                                    _
                                                                                    j
                                                                                    _
                                                                                  ) -> i GHC.Classes.== j
                                                                             )
                                                                            callInput
                                                                            failInp
                                                                            then
                                                                              let _ = "choicesBranch.then"
                                                                               in let _ = "catch ExceptionFailure"
                                                                                   in let catchHandler (!_exn) (!failInp) (!farInp) (!farExp) =
                                                                                            let _ = "catch.ko ExceptionFailure"
                                                                                             in if ( \( Data.Text.Internal.Text
                                                                                                          _
                                                                                                          i
                                                                                                          _
                                                                                                        )
                                                                                                      ( Data.Text.Internal.Text
                                                                                                          _
                                                                                                          j
                                                                                                          _
                                                                                                        ) -> i GHC.Classes.== j
                                                                                                   )
                                                                                                  failInp
                                                                                                  failInp
                                                                                                  then
                                                                                                    let _ = "choicesBranch.then"
                                                                                                     in let _ = "catch ExceptionFailure"
                                                                                                         in let catchHandler (!_exn) (!failInp) (!farInp) (!farExp) =
                                                                                                                  let _ = "catch.ko ExceptionFailure"
                                                                                                                   in if ( \( Data.Text.Internal.Text
                                                                                                                                _
                                                                                                                                i
                                                                                                                                _
                                                                                                                              )
                                                                                                                            ( Data.Text.Internal.Text
                                                                                                                                _
                                                                                                                                j
                                                                                                                                _
                                                                                                                              ) -> i GHC.Classes.== j
                                                                                                                         )
                                                                                                                        failInp
                                                                                                                        failInp
                                                                                                                        then
                                                                                                                          let _ = "choicesBranch.then"
                                                                                                                           in name
                                                                                                                                ( let _ = "suspend"
                                                                                                                                   in \farInp farExp v (!inp) ->
                                                                                                                                        name
                                                                                                                                          ( let _ = "suspend"
                                                                                                                                             in \farInp farExp v (!inp) ->
                                                                                                                                                  let _ = "resume"
                                                                                                                                                   in join
                                                                                                                                                        farInp
                                                                                                                                                        farExp
                                                                                                                                                        ( let _ = "resume.genCode"
                                                                                                                                                           in v
                                                                                                                                                        )
                                                                                                                                                        inp
                                                                                                                                          )
                                                                                                                                          inp
                                                                                                                                          (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure (catchHandler callInput) Data.Map.Internal.Tip Data.Map.Internal.Tip)
                                                                                                                                )
                                                                                                                                failInp
                                                                                                                                (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure (catchHandler callInput) Data.Map.Internal.Tip Data.Map.Internal.Tip)
                                                                                                                        else
                                                                                                                          let _ = "choicesBranch.else"
                                                                                                                           in catchHandler callInput Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp
                                                                                                             in let _ = "catch ExceptionFailure"
                                                                                                                 in let catchHandler (!_exn) (!failInp) (!farInp) (!farExp) =
                                                                                                                          let _ = "catch.ko ExceptionFailure"
                                                                                                                           in catchHandler Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp
                                                                                                                     in let join = \farInp farExp v (!inp) ->
                                                                                                                              name
                                                                                                                                ( let _ = "suspend"
                                                                                                                                   in \farInp farExp v (!inp) -> do
                                                                                                                                        let dupv = \x -> x
                                                                                                                                        reg <- GHC.STRef.newSTRef dupv
                                                                                                                                        let _ = "iter"
                                                                                                                                         in let catchHandler loopInput (!_exn) (!failInp) (!farInp) (!farExp) =
                                                                                                                                                  if ( \( Data.Text.Internal.Text
                                                                                                                                                            _
                                                                                                                                                            i
                                                                                                                                                            _
                                                                                                                                                          )
                                                                                                                                                        ( Data.Text.Internal.Text
                                                                                                                                                            _
                                                                                                                                                            j
                                                                                                                                                            _
                                                                                                                                                          ) -> i GHC.Classes.== j
                                                                                                                                                     )
                                                                                                                                                    loopInput
                                                                                                                                                    failInp
                                                                                                                                                    then
                                                                                                                                                      let _ = "choicesBranch.then"
                                                                                                                                                       in do
                                                                                                                                                            sr <- GHC.STRef.readSTRef reg
                                                                                                                                                            name
                                                                                                                                                              ( let _ = "suspend"
                                                                                                                                                                 in \farInp farExp v (!inp) ->
                                                                                                                                                                      name
                                                                                                                                                                        ( let _ = "suspend"
                                                                                                                                                                           in \farInp farExp v (!inp) ->
                                                                                                                                                                                let readFail = catchHandler
                                                                                                                                                                                 in if readMore inp
                                                                                                                                                                                      then
                                                                                                                                                                                        let !(#
                                                                                                                                                                                               c,
                                                                                                                                                                                               cs
                                                                                                                                                                                               #) = readNext inp
                                                                                                                                                                                         in if (GHC.Classes.==) '=' c
                                                                                                                                                                                              then
                                                                                                                                                                                                name
                                                                                                                                                                                                  ( let _ = "suspend"
                                                                                                                                                                                                     in \farInp farExp v (!inp) ->
                                                                                                                                                                                                          name
                                                                                                                                                                                                            ( let _ = "suspend"
                                                                                                                                                                                                               in \farInp farExp v (!inp) -> do
                                                                                                                                                                                                                    let dupv = \x -> x
                                                                                                                                                                                                                    reg <- GHC.STRef.newSTRef dupv
                                                                                                                                                                                                                    let _ = "iter"
                                                                                                                                                                                                                     in let catchHandler loopInput (!_exn) (!failInp) (!farInp) (!farExp) =
                                                                                                                                                                                                                              if ( \( Data.Text.Internal.Text
                                                                                                                                                                                                                                        _
                                                                                                                                                                                                                                        i
                                                                                                                                                                                                                                        _
                                                                                                                                                                                                                                      )
                                                                                                                                                                                                                                    ( Data.Text.Internal.Text
                                                                                                                                                                                                                                        _
                                                                                                                                                                                                                                        j
                                                                                                                                                                                                                                        _
                                                                                                                                                                                                                                      ) -> i GHC.Classes.== j
                                                                                                                                                                                                                                 )
                                                                                                                                                                                                                                loopInput
                                                                                                                                                                                                                                failInp
                                                                                                                                                                                                                                then
                                                                                                                                                                                                                                  let _ = "choicesBranch.then"
                                                                                                                                                                                                                                   in do
                                                                                                                                                                                                                                        sr <- GHC.STRef.readSTRef reg
                                                                                                                                                                                                                                        name
                                                                                                                                                                                                                                          ( let _ = "suspend"
                                                                                                                                                                                                                                             in \farInp farExp v (!inp) ->
                                                                                                                                                                                                                                                  name
                                                                                                                                                                                                                                                    ( let _ = "suspend"
                                                                                                                                                                                                                                                       in \farInp farExp v (!inp) ->
                                                                                                                                                                                                                                                            name
                                                                                                                                                                                                                                                              ( let _ = "suspend"
                                                                                                                                                                                                                                                                 in \farInp farExp v (!inp) ->
                                                                                                                                                                                                                                                                      let _ = "resume"
                                                                                                                                                                                                                                                                       in join
                                                                                                                                                                                                                                                                            farInp
                                                                                                                                                                                                                                                                            farExp
                                                                                                                                                                                                                                                                            ( let _ = "resume.genCode"
                                                                                                                                                                                                                                                                               in v
                                                                                                                                                                                                                                                                            )
                                                                                                                                                                                                                                                                            inp
                                                                                                                                                                                                                                                              )
                                                                                                                                                                                                                                                              inp
                                                                                                                                                                                                                                                              (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure readFail Data.Map.Internal.Tip Data.Map.Internal.Tip)
                                                                                                                                                                                                                                                    )
                                                                                                                                                                                                                                                    inp
                                                                                                                                                                                                                                                    Data.Map.Internal.Tip
                                                                                                                                                                                                                                          )
                                                                                                                                                                                                                                          failInp
                                                                                                                                                                                                                                          Data.Map.Internal.Tip
                                                                                                                                                                                                                                else
                                                                                                                                                                                                                                  let _ = "choicesBranch.else"
                                                                                                                                                                                                                                   in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp
                                                                                                                                                                                                                            loop = \_callReturn callInput callCatchStackByLabel ->
                                                                                                                                                                                                                              name
                                                                                                                                                                                                                                ( let _ = "suspend"
                                                                                                                                                                                                                                   in \farInp farExp v (!inp) ->
                                                                                                                                                                                                                                        name
                                                                                                                                                                                                                                          ( let _ = "suspend"
                                                                                                                                                                                                                                             in \farInp farExp v (!inp) ->
                                                                                                                                                                                                                                                  name
                                                                                                                                                                                                                                                    ( let _ = "suspend"
                                                                                                                                                                                                                                                       in \farInp farExp v (!inp) -> do
                                                                                                                                                                                                                                                            sr <- GHC.STRef.readSTRef reg
                                                                                                                                                                                                                                                            do
                                                                                                                                                                                                                                                              let dupv = v v sr
                                                                                                                                                                                                                                                              GHC.STRef.writeSTRef reg dupv
                                                                                                                                                                                                                                                              let _ = "jump"
                                                                                                                                                                                                                                                               in loop (GHC.Err.error "invalid return") inp (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure (catchHandler callInput) Data.Map.Internal.Tip Data.Map.Internal.Tip)
                                                                                                                                                                                                                                                    )
                                                                                                                                                                                                                                                    inp
                                                                                                                                                                                                                                                    (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure (catchHandler callInput) Data.Map.Internal.Tip Data.Map.Internal.Tip)
                                                                                                                                                                                                                                          )
                                                                                                                                                                                                                                          inp
                                                                                                                                                                                                                                          (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure (catchHandler callInput) Data.Map.Internal.Tip Data.Map.Internal.Tip)
                                                                                                                                                                                                                                )
                                                                                                                                                                                                                                callInput
                                                                                                                                                                                                                                Data.Map.Internal.Tip
                                                                                                                                                                                                                         in let _ = "jump"
                                                                                                                                                                                                                             in loop (GHC.Err.error "invalid return") inp (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure readFail Data.Map.Internal.Tip Data.Map.Internal.Tip)
                                                                                                                                                                                                            )
                                                                                                                                                                                                            inp
                                                                                                                                                                                                            (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure readFail Data.Map.Internal.Tip Data.Map.Internal.Tip)
                                                                                                                                                                                                  )
                                                                                                                                                                                                  cs
                                                                                                                                                                                                  (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure readFail Data.Map.Internal.Tip Data.Map.Internal.Tip)
                                                                                                                                                                                              else
                                                                                                                                                                                                let _ = "checkToken.else"
                                                                                                                                                                                                 in let failExp =
                                                                                                                                                                                                          Data.Set.Internal.Bin
                                                                                                                                                                                                            1
                                                                                                                                                                                                            ( Symantic.Parser.Grammar.Combinators.SomeFailure
                                                                                                                                                                                                                ( case inputToken of
                                                                                                                                                                                                                    (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken '='
                                                                                                                                                                                                                )
                                                                                                                                                                                                            )
                                                                                                                                                                                                            Data.Set.Internal.Tip
                                                                                                                                                                                                            Data.Set.Internal.Tip
                                                                                                                                                                                                     in let (#
                                                                                                                                                                                                              farInp,
                                                                                                                                                                                                              farExp
                                                                                                                                                                                                              #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp inp of
                                                                                                                                                                                                                GHC.Types.LT ->
                                                                                                                                                                                                                  (#
                                                                                                                                                                                                                    inp,
                                                                                                                                                                                                                    failExp
                                                                                                                                                                                                                  #)
                                                                                                                                                                                                                GHC.Types.EQ ->
                                                                                                                                                                                                                  (#
                                                                                                                                                                                                                    farInp,
                                                                                                                                                                                                                    failExp GHC.Base.<> farExp
                                                                                                                                                                                                                  #)
                                                                                                                                                                                                                GHC.Types.GT ->
                                                                                                                                                                                                                  (#
                                                                                                                                                                                                                    farInp,
                                                                                                                                                                                                                    farExp
                                                                                                                                                                                                                  #)
                                                                                                                                                                                                         in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp
                                                                                                                                                                                      else
                                                                                                                                                                                        let _ = "checkHorizon.else"
                                                                                                                                                                                         in let failExp =
                                                                                                                                                                                                  Data.Set.Internal.Bin
                                                                                                                                                                                                    1
                                                                                                                                                                                                    ( Symantic.Parser.Grammar.Combinators.SomeFailure
                                                                                                                                                                                                        ( case inputToken of
                                                                                                                                                                                                            (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 1
                                                                                                                                                                                                        )
                                                                                                                                                                                                    )
                                                                                                                                                                                                    Data.Set.Internal.Tip
                                                                                                                                                                                                    Data.Set.Internal.Tip
                                                                                                                                                                                             in let (#
                                                                                                                                                                                                      farInp,
                                                                                                                                                                                                      farExp
                                                                                                                                                                                                      #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp inp of
                                                                                                                                                                                                        GHC.Types.LT ->
                                                                                                                                                                                                          (#
                                                                                                                                                                                                            inp,
                                                                                                                                                                                                            failExp
                                                                                                                                                                                                          #)
                                                                                                                                                                                                        GHC.Types.EQ ->
                                                                                                                                                                                                          (#
                                                                                                                                                                                                            farInp,
                                                                                                                                                                                                            failExp GHC.Base.<> farExp
                                                                                                                                                                                                          #)
                                                                                                                                                                                                        GHC.Types.GT ->
                                                                                                                                                                                                          (#
                                                                                                                                                                                                            farInp,
                                                                                                                                                                                                            farExp
                                                                                                                                                                                                          #)
                                                                                                                                                                                                 in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp
                                                                                                                                                                        )
                                                                                                                                                                        inp
                                                                                                                                                                        Data.Map.Internal.Tip
                                                                                                                                                              )
                                                                                                                                                              failInp
                                                                                                                                                              Data.Map.Internal.Tip
                                                                                                                                                    else
                                                                                                                                                      let _ = "choicesBranch.else"
                                                                                                                                                       in catchHandler Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp
                                                                                                                                                loop = \_callReturn callInput callCatchStackByLabel ->
                                                                                                                                                  name
                                                                                                                                                    ( let _ = "suspend"
                                                                                                                                                       in \farInp farExp v (!inp) ->
                                                                                                                                                            name
                                                                                                                                                              ( let _ = "suspend"
                                                                                                                                                                 in \farInp farExp v (!inp) ->
                                                                                                                                                                      name
                                                                                                                                                                        ( let _ = "suspend"
                                                                                                                                                                           in \farInp farExp v (!inp) -> do
                                                                                                                                                                                sr <- GHC.STRef.readSTRef reg
                                                                                                                                                                                do
                                                                                                                                                                                  let dupv = v v sr
                                                                                                                                                                                  GHC.STRef.writeSTRef reg dupv
                                                                                                                                                                                  let _ = "jump"
                                                                                                                                                                                   in loop (GHC.Err.error "invalid return") inp (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure (catchHandler callInput) Data.Map.Internal.Tip Data.Map.Internal.Tip)
                                                                                                                                                                        )
                                                                                                                                                                        inp
                                                                                                                                                                        (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure (catchHandler callInput) Data.Map.Internal.Tip Data.Map.Internal.Tip)
                                                                                                                                                              )
                                                                                                                                                              inp
                                                                                                                                                              (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure (catchHandler callInput) Data.Map.Internal.Tip Data.Map.Internal.Tip)
                                                                                                                                                    )
                                                                                                                                                    callInput
                                                                                                                                                    Data.Map.Internal.Tip
                                                                                                                                             in let _ = "jump"
                                                                                                                                                 in loop (GHC.Err.error "invalid return") inp (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure catchHandler Data.Map.Internal.Tip Data.Map.Internal.Tip)
                                                                                                                                )
                                                                                                                                inp
                                                                                                                                (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure catchHandler Data.Map.Internal.Tip Data.Map.Internal.Tip)
                                                                                                                         in let _ = "catch ExceptionFailure"
                                                                                                                             in let catchHandler (!_exn) (!failInp) (!farInp) (!farExp) =
                                                                                                                                      let _ = "catch.ko ExceptionFailure"
                                                                                                                                       in if ( \( Data.Text.Internal.Text
                                                                                                                                                    _
                                                                                                                                                    i
                                                                                                                                                    _
                                                                                                                                                  )
                                                                                                                                                ( Data.Text.Internal.Text
                                                                                                                                                    _
                                                                                                                                                    j
                                                                                                                                                    _
                                                                                                                                                  ) -> i GHC.Classes.== j
                                                                                                                                             )
                                                                                                                                            failInp
                                                                                                                                            failInp
                                                                                                                                            then
                                                                                                                                              let _ = "choicesBranch.then"
                                                                                                                                               in name
                                                                                                                                                    ( let _ = "suspend"
                                                                                                                                                       in \farInp farExp v (!inp) ->
                                                                                                                                                            let _ = "resume"
                                                                                                                                                             in join
                                                                                                                                                                  farInp
                                                                                                                                                                  farExp
                                                                                                                                                                  ( let _ = "resume.genCode"
                                                                                                                                                                     in v
                                                                                                                                                                  )
                                                                                                                                                                  inp
                                                                                                                                                    )
                                                                                                                                                    failInp
                                                                                                                                                    Data.Map.Internal.Tip
                                                                                                                                            else
                                                                                                                                              let _ = "choicesBranch.else"
                                                                                                                                               in catchHandler Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp
                                                                                                                                 in let _ = "catch ExceptionFailure"
                                                                                                                                     in let catchHandler (!_exn) (!failInp) (!farInp) (!farExp) =
                                                                                                                                              let _ = "catch.ko ExceptionFailure"
                                                                                                                                               in catchHandler Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp
                                                                                                                                         in let readFail = catchHandler
                                                                                                                                             in if readMore (Symantic.Parser.Machine.Input.shiftRightText 12 failInp)
                                                                                                                                                  then
                                                                                                                                                    let !(#
                                                                                                                                                           c,
                                                                                                                                                           cs
                                                                                                                                                           #) = readNext failInp
                                                                                                                                                     in if (GHC.Classes.==) 'v' c
                                                                                                                                                          then
                                                                                                                                                            let readFail = readFail
                                                                                                                                                             in let !(#
                                                                                                                                                                       c,
                                                                                                                                                                       cs
                                                                                                                                                                       #) = readNext cs
                                                                                                                                                                 in if (GHC.Classes.==) 'a' c
                                                                                                                                                                      then
                                                                                                                                                                        let readFail = readFail
                                                                                                                                                                         in let !(#
                                                                                                                                                                                   c,
                                                                                                                                                                                   cs
                                                                                                                                                                                   #) = readNext cs
                                                                                                                                                                             in if (GHC.Classes.==) 'r' c
                                                                                                                                                                                  then
                                                                                                                                                                                    name
                                                                                                                                                                                      ( let _ = "suspend"
                                                                                                                                                                                         in \farInp farExp v (!inp) ->
                                                                                                                                                                                              let _ = "resume"
                                                                                                                                                                                               in join
                                                                                                                                                                                                    farInp
                                                                                                                                                                                                    farExp
                                                                                                                                                                                                    ( let _ = "resume.genCode"
                                                                                                                                                                                                       in GHC.Tuple . ()
                                                                                                                                                                                                    )
                                                                                                                                                                                                    inp
                                                                                                                                                                                      )
                                                                                                                                                                                      cs
                                                                                                                                                                                      Data.Map.Internal.Tip
                                                                                                                                                                                  else
                                                                                                                                                                                    let _ = "checkToken.else"
                                                                                                                                                                                     in let failExp =
                                                                                                                                                                                              Data.Set.Internal.Bin
                                                                                                                                                                                                1
                                                                                                                                                                                                ( Symantic.Parser.Grammar.Combinators.SomeFailure
                                                                                                                                                                                                    ( case inputToken of
                                                                                                                                                                                                        (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'r'
                                                                                                                                                                                                    )
                                                                                                                                                                                                )
                                                                                                                                                                                                Data.Set.Internal.Tip
                                                                                                                                                                                                Data.Set.Internal.Tip
                                                                                                                                                                                         in let (#
                                                                                                                                                                                                  farInp,
                                                                                                                                                                                                  farExp
                                                                                                                                                                                                  #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp cs of
                                                                                                                                                                                                    GHC.Types.LT ->
                                                                                                                                                                                                      (#
                                                                                                                                                                                                        cs,
                                                                                                                                                                                                        failExp
                                                                                                                                                                                                      #)
                                                                                                                                                                                                    GHC.Types.EQ ->
                                                                                                                                                                                                      (#
                                                                                                                                                                                                        farInp,
                                                                                                                                                                                                        failExp GHC.Base.<> farExp
                                                                                                                                                                                                      #)
                                                                                                                                                                                                    GHC.Types.GT ->
                                                                                                                                                                                                      (#
                                                                                                                                                                                                        farInp,
                                                                                                                                                                                                        farExp
                                                                                                                                                                                                      #)
                                                                                                                                                                                             in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure cs farInp farExp
                                                                                                                                                                      else
                                                                                                                                                                        let _ = "checkToken.else"
                                                                                                                                                                         in let failExp =
                                                                                                                                                                                  Data.Set.Internal.Bin
                                                                                                                                                                                    1
                                                                                                                                                                                    ( Symantic.Parser.Grammar.Combinators.SomeFailure
                                                                                                                                                                                        ( case inputToken of
                                                                                                                                                                                            (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'a'
                                                                                                                                                                                        )
                                                                                                                                                                                    )
                                                                                                                                                                                    Data.Set.Internal.Tip
                                                                                                                                                                                    Data.Set.Internal.Tip
                                                                                                                                                                             in let (#
                                                                                                                                                                                      farInp,
                                                                                                                                                                                      farExp
                                                                                                                                                                                      #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp cs of
                                                                                                                                                                                        GHC.Types.LT ->
                                                                                                                                                                                          (#
                                                                                                                                                                                            cs,
                                                                                                                                                                                            failExp
                                                                                                                                                                                          #)
                                                                                                                                                                                        GHC.Types.EQ ->
                                                                                                                                                                                          (#
                                                                                                                                                                                            farInp,
                                                                                                                                                                                            failExp GHC.Base.<> farExp
                                                                                                                                                                                          #)
                                                                                                                                                                                        GHC.Types.GT ->
                                                                                                                                                                                          (#
                                                                                                                                                                                            farInp,
                                                                                                                                                                                            farExp
                                                                                                                                                                                          #)
                                                                                                                                                                                 in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure cs farInp farExp
                                                                                                                                                          else
                                                                                                                                                            let _ = "checkToken.else"
                                                                                                                                                             in let failExp =
                                                                                                                                                                      Data.Set.Internal.Bin
                                                                                                                                                                        1
                                                                                                                                                                        ( Symantic.Parser.Grammar.Combinators.SomeFailure
                                                                                                                                                                            ( case inputToken of
                                                                                                                                                                                (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'v'
                                                                                                                                                                            )
                                                                                                                                                                        )
                                                                                                                                                                        Data.Set.Internal.Tip
                                                                                                                                                                        Data.Set.Internal.Tip
                                                                                                                                                                 in let (#
                                                                                                                                                                          farInp,
                                                                                                                                                                          farExp
                                                                                                                                                                          #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp failInp of
                                                                                                                                                                            GHC.Types.LT ->
                                                                                                                                                                              (#
                                                                                                                                                                                failInp,
                                                                                                                                                                                failExp
                                                                                                                                                                              #)
                                                                                                                                                                            GHC.Types.EQ ->
                                                                                                                                                                              (#
                                                                                                                                                                                farInp,
                                                                                                                                                                                failExp GHC.Base.<> farExp
                                                                                                                                                                              #)
                                                                                                                                                                            GHC.Types.GT ->
                                                                                                                                                                              (#
                                                                                                                                                                                farInp,
                                                                                                                                                                                farExp
                                                                                                                                                                              #)
                                                                                                                                                                     in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp
                                                                                                                                                  else
                                                                                                                                                    let _ = "checkHorizon.else"
                                                                                                                                                     in let failExp =
                                                                                                                                                              Data.Set.Internal.Bin
                                                                                                                                                                1
                                                                                                                                                                ( Symantic.Parser.Grammar.Combinators.SomeFailure
                                                                                                                                                                    ( case inputToken of
                                                                                                                                                                        (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 13
                                                                                                                                                                    )
                                                                                                                                                                )
                                                                                                                                                                Data.Set.Internal.Tip
                                                                                                                                                                Data.Set.Internal.Tip
                                                                                                                                                         in let (#
                                                                                                                                                                  farInp,
                                                                                                                                                                  farExp
                                                                                                                                                                  #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp failInp of
                                                                                                                                                                    GHC.Types.LT ->
                                                                                                                                                                      (#
                                                                                                                                                                        failInp,
                                                                                                                                                                        failExp
                                                                                                                                                                      #)
                                                                                                                                                                    GHC.Types.EQ ->
                                                                                                                                                                      (#
                                                                                                                                                                        farInp,
                                                                                                                                                                        failExp GHC.Base.<> farExp
                                                                                                                                                                      #)
                                                                                                                                                                    GHC.Types.GT ->
                                                                                                                                                                      (#
                                                                                                                                                                        farInp,
                                                                                                                                                                        farExp
                                                                                                                                                                      #)
                                                                                                                                                             in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp
                                                                                                  else
                                                                                                    let _ = "choicesBranch.else"
                                                                                                     in catchHandler callInput Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp
                                                                                       in let _ = "catch ExceptionFailure"
                                                                                           in let catchHandler (!_exn) (!failInp) (!farInp) (!farExp) =
                                                                                                    let _ = "catch.ko ExceptionFailure"
                                                                                                     in catchHandler Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp
                                                                                               in let readFail = catchHandler
                                                                                                   in if readMore (Symantic.Parser.Machine.Input.shiftRightText 12 failInp)
                                                                                                        then
                                                                                                          let !(#
                                                                                                                 c,
                                                                                                                 cs
                                                                                                                 #) = readNext failInp
                                                                                                           in if (GHC.Classes.==) 'w' c
                                                                                                                then
                                                                                                                  let readFail = readFail
                                                                                                                   in let !(#
                                                                                                                             c,
                                                                                                                             cs
                                                                                                                             #) = readNext cs
                                                                                                                       in if (GHC.Classes.==) 'h' c
                                                                                                                            then
                                                                                                                              let readFail = readFail
                                                                                                                               in let !(#
                                                                                                                                         c,
                                                                                                                                         cs
                                                                                                                                         #) = readNext cs
                                                                                                                                   in if (GHC.Classes.==) 'i' c
                                                                                                                                        then
                                                                                                                                          let readFail = readFail
                                                                                                                                           in let !(#
                                                                                                                                                     c,
                                                                                                                                                     cs
                                                                                                                                                     #) = readNext cs
                                                                                                                                               in if (GHC.Classes.==) 'l' c
                                                                                                                                                    then
                                                                                                                                                      let readFail = readFail
                                                                                                                                                       in let !(#
                                                                                                                                                                 c,
                                                                                                                                                                 cs
                                                                                                                                                                 #) = readNext cs
                                                                                                                                                           in if (GHC.Classes.==) 'e' c
                                                                                                                                                                then
                                                                                                                                                                  name
                                                                                                                                                                    ( let _ = "suspend"
                                                                                                                                                                       in \farInp farExp v (!inp) ->
                                                                                                                                                                            name
                                                                                                                                                                              ( let _ = "suspend"
                                                                                                                                                                                 in \farInp farExp v (!inp) ->
                                                                                                                                                                                      name
                                                                                                                                                                                        ( let _ = "suspend"
                                                                                                                                                                                           in \farInp farExp v (!inp) ->
                                                                                                                                                                                                let _ = "resume"
                                                                                                                                                                                                 in join
                                                                                                                                                                                                      farInp
                                                                                                                                                                                                      farExp
                                                                                                                                                                                                      ( let _ = "resume.genCode"
                                                                                                                                                                                                         in v
                                                                                                                                                                                                      )
                                                                                                                                                                                                      inp
                                                                                                                                                                                        )
                                                                                                                                                                                        inp
                                                                                                                                                                                        (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure catchHandler Data.Map.Internal.Tip Data.Map.Internal.Tip)
                                                                                                                                                                              )
                                                                                                                                                                              inp
                                                                                                                                                                              (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure catchHandler Data.Map.Internal.Tip Data.Map.Internal.Tip)
                                                                                                                                                                    )
                                                                                                                                                                    cs
                                                                                                                                                                    Data.Map.Internal.Tip
                                                                                                                                                                else
                                                                                                                                                                  let _ = "checkToken.else"
                                                                                                                                                                   in let failExp =
                                                                                                                                                                            Data.Set.Internal.Bin
                                                                                                                                                                              1
                                                                                                                                                                              ( Symantic.Parser.Grammar.Combinators.SomeFailure
                                                                                                                                                                                  ( case inputToken of
                                                                                                                                                                                      (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'e'
                                                                                                                                                                                  )
                                                                                                                                                                              )
                                                                                                                                                                              Data.Set.Internal.Tip
                                                                                                                                                                              Data.Set.Internal.Tip
                                                                                                                                                                       in let (#
                                                                                                                                                                                farInp,
                                                                                                                                                                                farExp
                                                                                                                                                                                #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp cs of
                                                                                                                                                                                  GHC.Types.LT ->
                                                                                                                                                                                    (#
                                                                                                                                                                                      cs,
                                                                                                                                                                                      failExp
                                                                                                                                                                                    #)
                                                                                                                                                                                  GHC.Types.EQ ->
                                                                                                                                                                                    (#
                                                                                                                                                                                      farInp,
                                                                                                                                                                                      failExp GHC.Base.<> farExp
                                                                                                                                                                                    #)
                                                                                                                                                                                  GHC.Types.GT ->
                                                                                                                                                                                    (#
                                                                                                                                                                                      farInp,
                                                                                                                                                                                      farExp
                                                                                                                                                                                    #)
                                                                                                                                                                           in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure cs farInp farExp
                                                                                                                                                    else
                                                                                                                                                      let _ = "checkToken.else"
                                                                                                                                                       in let failExp =
                                                                                                                                                                Data.Set.Internal.Bin
                                                                                                                                                                  1
                                                                                                                                                                  ( Symantic.Parser.Grammar.Combinators.SomeFailure
                                                                                                                                                                      ( case inputToken of
                                                                                                                                                                          (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'l'
                                                                                                                                                                      )
                                                                                                                                                                  )
                                                                                                                                                                  Data.Set.Internal.Tip
                                                                                                                                                                  Data.Set.Internal.Tip
                                                                                                                                                           in let (#
                                                                                                                                                                    farInp,
                                                                                                                                                                    farExp
                                                                                                                                                                    #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp cs of
                                                                                                                                                                      GHC.Types.LT ->
                                                                                                                                                                        (#
                                                                                                                                                                          cs,
                                                                                                                                                                          failExp
                                                                                                                                                                        #)
                                                                                                                                                                      GHC.Types.EQ ->
                                                                                                                                                                        (#
                                                                                                                                                                          farInp,
                                                                                                                                                                          failExp GHC.Base.<> farExp
                                                                                                                                                                        #)
                                                                                                                                                                      GHC.Types.GT ->
                                                                                                                                                                        (#
                                                                                                                                                                          farInp,
                                                                                                                                                                          farExp
                                                                                                                                                                        #)
                                                                                                                                                               in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure cs farInp farExp
                                                                                                                                        else
                                                                                                                                          let _ = "checkToken.else"
                                                                                                                                           in let failExp =
                                                                                                                                                    Data.Set.Internal.Bin
                                                                                                                                                      1
                                                                                                                                                      ( Symantic.Parser.Grammar.Combinators.SomeFailure
                                                                                                                                                          ( case inputToken of
                                                                                                                                                              (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'i'
                                                                                                                                                          )
                                                                                                                                                      )
                                                                                                                                                      Data.Set.Internal.Tip
                                                                                                                                                      Data.Set.Internal.Tip
                                                                                                                                               in let (#
                                                                                                                                                        farInp,
                                                                                                                                                        farExp
                                                                                                                                                        #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp cs of
                                                                                                                                                          GHC.Types.LT ->
                                                                                                                                                            (#
                                                                                                                                                              cs,
                                                                                                                                                              failExp
                                                                                                                                                            #)
                                                                                                                                                          GHC.Types.EQ ->
                                                                                                                                                            (#
                                                                                                                                                              farInp,
                                                                                                                                                              failExp GHC.Base.<> farExp
                                                                                                                                                            #)
                                                                                                                                                          GHC.Types.GT ->
                                                                                                                                                            (#
                                                                                                                                                              farInp,
                                                                                                                                                              farExp
                                                                                                                                                            #)
                                                                                                                                                   in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure cs farInp farExp
                                                                                                                            else
                                                                                                                              let _ = "checkToken.else"
                                                                                                                               in let failExp =
                                                                                                                                        Data.Set.Internal.Bin
                                                                                                                                          1
                                                                                                                                          ( Symantic.Parser.Grammar.Combinators.SomeFailure
                                                                                                                                              ( case inputToken of
                                                                                                                                                  (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'h'
                                                                                                                                              )
                                                                                                                                          )
                                                                                                                                          Data.Set.Internal.Tip
                                                                                                                                          Data.Set.Internal.Tip
                                                                                                                                   in let (#
                                                                                                                                            farInp,
                                                                                                                                            farExp
                                                                                                                                            #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp cs of
                                                                                                                                              GHC.Types.LT ->
                                                                                                                                                (#
                                                                                                                                                  cs,
                                                                                                                                                  failExp
                                                                                                                                                #)
                                                                                                                                              GHC.Types.EQ ->
                                                                                                                                                (#
                                                                                                                                                  farInp,
                                                                                                                                                  failExp GHC.Base.<> farExp
                                                                                                                                                #)
                                                                                                                                              GHC.Types.GT ->
                                                                                                                                                (#
                                                                                                                                                  farInp,
                                                                                                                                                  farExp
                                                                                                                                                #)
                                                                                                                                       in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure cs farInp farExp
                                                                                                                else
                                                                                                                  let _ = "checkToken.else"
                                                                                                                   in let failExp =
                                                                                                                            Data.Set.Internal.Bin
                                                                                                                              1
                                                                                                                              ( Symantic.Parser.Grammar.Combinators.SomeFailure
                                                                                                                                  ( case inputToken of
                                                                                                                                      (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'w'
                                                                                                                                  )
                                                                                                                              )
                                                                                                                              Data.Set.Internal.Tip
                                                                                                                              Data.Set.Internal.Tip
                                                                                                                       in let (#
                                                                                                                                farInp,
                                                                                                                                farExp
                                                                                                                                #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp failInp of
                                                                                                                                  GHC.Types.LT ->
                                                                                                                                    (#
                                                                                                                                      failInp,
                                                                                                                                      failExp
                                                                                                                                    #)
                                                                                                                                  GHC.Types.EQ ->
                                                                                                                                    (#
                                                                                                                                      farInp,
                                                                                                                                      failExp GHC.Base.<> farExp
                                                                                                                                    #)
                                                                                                                                  GHC.Types.GT ->
                                                                                                                                    (#
                                                                                                                                      farInp,
                                                                                                                                      farExp
                                                                                                                                    #)
                                                                                                                           in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp
                                                                                                        else
                                                                                                          let _ = "checkHorizon.else"
                                                                                                           in let failExp =
                                                                                                                    Data.Set.Internal.Bin
                                                                                                                      1
                                                                                                                      ( Symantic.Parser.Grammar.Combinators.SomeFailure
                                                                                                                          ( case inputToken of
                                                                                                                              (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 13
                                                                                                                          )
                                                                                                                      )
                                                                                                                      Data.Set.Internal.Tip
                                                                                                                      Data.Set.Internal.Tip
                                                                                                               in let (#
                                                                                                                        farInp,
                                                                                                                        farExp
                                                                                                                        #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp failInp of
                                                                                                                          GHC.Types.LT ->
                                                                                                                            (#
                                                                                                                              failInp,
                                                                                                                              failExp
                                                                                                                            #)
                                                                                                                          GHC.Types.EQ ->
                                                                                                                            (#
                                                                                                                              farInp,
                                                                                                                              failExp GHC.Base.<> farExp
                                                                                                                            #)
                                                                                                                          GHC.Types.GT ->
                                                                                                                            (#
                                                                                                                              farInp,
                                                                                                                              farExp
                                                                                                                            #)
                                                                                                                   in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp
                                                                            else
                                                                              let _ = "choicesBranch.else"
                                                                               in catchHandler callInput Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp
                                                                 in let _ = "catch ExceptionFailure"
                                                                     in let catchHandler (!_exn) (!failInp) (!farInp) (!farExp) =
                                                                              let _ = "catch.ko ExceptionFailure"
                                                                               in catchHandler Symantic.Parser.Grammar.Combinators.ExceptionFailure callInput farInp farExp
                                                                         in let readFail = catchHandler
                                                                             in if readMore (Symantic.Parser.Machine.Input.shiftRightText 3 callInput)
                                                                                  then
                                                                                    let !(#
                                                                                           c,
                                                                                           cs
                                                                                           #) = readNext callInput
                                                                                     in if (GHC.Classes.==) 'i' c
                                                                                          then
                                                                                            let readFail = readFail
                                                                                             in let !(#
                                                                                                       c,
                                                                                                       cs
                                                                                                       #) = readNext cs
                                                                                                 in if (GHC.Classes.==) 'f' c
                                                                                                      then
                                                                                                        name
                                                                                                          ( let _ = "suspend"
                                                                                                             in \farInp farExp v (!inp) ->
                                                                                                                  let _ = "resume"
                                                                                                                   in join
                                                                                                                        farInp
                                                                                                                        farExp
                                                                                                                        ( let _ = "resume.genCode"
                                                                                                                           in v
                                                                                                                        )
                                                                                                                        inp
                                                                                                          )
                                                                                                          cs
                                                                                                          Data.Map.Internal.Tip
                                                                                                      else
                                                                                                        let _ = "checkToken.else"
                                                                                                         in let failExp =
                                                                                                                  Data.Set.Internal.Bin
                                                                                                                    1
                                                                                                                    ( Symantic.Parser.Grammar.Combinators.SomeFailure
                                                                                                                        ( case inputToken of
                                                                                                                            (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'f'
                                                                                                                        )
                                                                                                                    )
                                                                                                                    Data.Set.Internal.Tip
                                                                                                                    Data.Set.Internal.Tip
                                                                                                             in let (#
                                                                                                                      farInp,
                                                                                                                      farExp
                                                                                                                      #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp cs of
                                                                                                                        GHC.Types.LT ->
                                                                                                                          (#
                                                                                                                            cs,
                                                                                                                            failExp
                                                                                                                          #)
                                                                                                                        GHC.Types.EQ ->
                                                                                                                          (#
                                                                                                                            farInp,
                                                                                                                            failExp GHC.Base.<> farExp
                                                                                                                          #)
                                                                                                                        GHC.Types.GT ->
                                                                                                                          (#
                                                                                                                            farInp,
                                                                                                                            farExp
                                                                                                                          #)
                                                                                                                 in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure cs farInp farExp
                                                                                          else
                                                                                            let _ = "checkToken.else"
                                                                                             in let failExp =
                                                                                                      Data.Set.Internal.Bin
                                                                                                        1
                                                                                                        ( Symantic.Parser.Grammar.Combinators.SomeFailure
                                                                                                            ( case inputToken of
                                                                                                                (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'i'
                                                                                                            )
                                                                                                        )
                                                                                                        Data.Set.Internal.Tip
                                                                                                        Data.Set.Internal.Tip
                                                                                                 in let (#
                                                                                                          farInp,
                                                                                                          farExp
                                                                                                          #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp callInput of
                                                                                                            GHC.Types.LT ->
                                                                                                              (#
                                                                                                                callInput,
                                                                                                                failExp
                                                                                                              #)
                                                                                                            GHC.Types.EQ ->
                                                                                                              (#
                                                                                                                farInp,
                                                                                                                failExp GHC.Base.<> farExp
                                                                                                              #)
                                                                                                            GHC.Types.GT ->
                                                                                                              (#
                                                                                                                farInp,
                                                                                                                farExp
                                                                                                              #)
                                                                                                     in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure callInput farInp farExp
                                                                                  else
                                                                                    let _ = "checkHorizon.else"
                                                                                     in let failExp =
                                                                                              Data.Set.Internal.Bin
                                                                                                1
                                                                                                ( Symantic.Parser.Grammar.Combinators.SomeFailure
                                                                                                    ( case inputToken of
                                                                                                        (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 4
                                                                                                    )
                                                                                                )
                                                                                                Data.Set.Internal.Tip
                                                                                                Data.Set.Internal.Tip
                                                                                         in let (#
                                                                                                  farInp,
                                                                                                  farExp
                                                                                                  #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp callInput of
                                                                                                    GHC.Types.LT ->
                                                                                                      (#
                                                                                                        callInput,
                                                                                                        failExp
                                                                                                      #)
                                                                                                    GHC.Types.EQ ->
                                                                                                      (#
                                                                                                        farInp,
                                                                                                        failExp GHC.Base.<> farExp
                                                                                                      #)
                                                                                                    GHC.Types.GT ->
                                                                                                      (#
                                                                                                        farInp,
                                                                                                        farExp
                                                                                                      #)
                                                                                             in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure callInput farInp farExp
                                                   in let _ = "jump"
                                                       in loop callReturn inp (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure readFail Data.Map.Internal.Tip Data.Map.Internal.Tip)
                                      )
                                      cs
                                      (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure readFail Data.Map.Internal.Tip Data.Map.Internal.Tip)
                                  else
                                    let _ = "checkToken.else"
                                     in let failExp =
                                              Data.Set.Internal.Bin
                                                1
                                                ( Symantic.Parser.Grammar.Combinators.SomeFailure
                                                    ( case inputToken of
                                                        (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken '{'
                                                    )
                                                )
                                                Data.Set.Internal.Tip
                                                Data.Set.Internal.Tip
                                         in let (#
                                                  farInp,
                                                  farExp
                                                  #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init callInput of
                                                    GHC.Types.LT ->
                                                      (#
                                                        callInput,
                                                        failExp
                                                      #)
                                                    GHC.Types.EQ ->
                                                      (#
                                                        init,
                                                        failExp GHC.Base.<> Data.Set.Internal.empty
                                                      #)
                                                    GHC.Types.GT ->
                                                      (#
                                                        init,
                                                        Data.Set.Internal.empty
                                                      #)
                                             in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure callInput farInp farExp
                          else
                            let _ = "checkHorizon.else"
                             in let failExp =
                                      Data.Set.Internal.Bin
                                        1
                                        ( Symantic.Parser.Grammar.Combinators.SomeFailure
                                            ( case inputToken of
                                                (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 4
                                            )
                                        )
                                        Data.Set.Internal.Tip
                                        Data.Set.Internal.Tip
                                 in let (#
                                          farInp,
                                          farExp
                                          #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init callInput of
                                            GHC.Types.LT ->
                                              (#
                                                callInput,
                                                failExp
                                              #)
                                            GHC.Types.EQ ->
                                              (#
                                                init,
                                                failExp GHC.Base.<> Data.Set.Internal.empty
                                              #)
                                            GHC.Types.GT ->
                                              (#
                                                init,
                                                Data.Set.Internal.empty
                                              #)
                                     in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure callInput farInp farExp
                  name = \(!callReturn) (!callInput) (!callCatchStackByLabel) ->
                    let readFail = Data.Map.Strict.Internal.findWithDefault finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure callCatchStackByLabel
                     in if readMore (Symantic.Parser.Machine.Input.shiftRightText 4 callInput)
                          then
                            let !(#
                                   c,
                                   cs
                                   #) = readNext callInput
                             in if (GHC.Classes.==) '[' c
                                  then
                                    name
                                      ( let _ = "suspend"
                                         in \farInp farExp v (!inp) ->
                                              name
                                                ( let _ = "suspend"
                                                   in \farInp farExp v (!inp) -> do
                                                        let dupv = \x -> x
                                                        reg <- GHC.STRef.newSTRef dupv
                                                        let _ = "iter"
                                                         in let catchHandler loopInput (!_exn) (!failInp) (!farInp) (!farExp) =
                                                                  if ( \( Data.Text.Internal.Text
                                                                            _
                                                                            i
                                                                            _
                                                                          )
                                                                        ( Data.Text.Internal.Text
                                                                            _
                                                                            j
                                                                            _
                                                                          ) -> i GHC.Classes.== j
                                                                     )
                                                                    loopInput
                                                                    failInp
                                                                    then
                                                                      let _ = "choicesBranch.then"
                                                                       in do
                                                                            sr <- GHC.STRef.readSTRef reg
                                                                            let readFail = readFail
                                                                             in if readMore failInp
                                                                                  then
                                                                                    let !(#
                                                                                           c,
                                                                                           cs
                                                                                           #) = readNext failInp
                                                                                     in if (GHC.Classes.==) ']' c
                                                                                          then
                                                                                            name
                                                                                              ( let _ = "suspend"
                                                                                                 in \farInp farExp v (!inp) ->
                                                                                                      let _ = "resume"
                                                                                                       in callReturn
                                                                                                            farInp
                                                                                                            farExp
                                                                                                            ( let _ = "resume.genCode"
                                                                                                               in GHC.Tuple . ()
                                                                                                            )
                                                                                                            inp
                                                                                              )
                                                                                              cs
                                                                                              (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure readFail Data.Map.Internal.Tip Data.Map.Internal.Tip)
                                                                                          else
                                                                                            let _ = "checkToken.else"
                                                                                             in let failExp =
                                                                                                      Data.Set.Internal.Bin
                                                                                                        1
                                                                                                        ( Symantic.Parser.Grammar.Combinators.SomeFailure
                                                                                                            ( case inputToken of
                                                                                                                (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken ']'
                                                                                                            )
                                                                                                        )
                                                                                                        Data.Set.Internal.Tip
                                                                                                        Data.Set.Internal.Tip
                                                                                                 in let (#
                                                                                                          farInp,
                                                                                                          farExp
                                                                                                          #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp failInp of
                                                                                                            GHC.Types.LT ->
                                                                                                              (#
                                                                                                                failInp,
                                                                                                                failExp
                                                                                                              #)
                                                                                                            GHC.Types.EQ ->
                                                                                                              (#
                                                                                                                farInp,
                                                                                                                failExp GHC.Base.<> farExp
                                                                                                              #)
                                                                                                            GHC.Types.GT ->
                                                                                                              (#
                                                                                                                farInp,
                                                                                                                farExp
                                                                                                              #)
                                                                                                     in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp
                                                                                  else
                                                                                    let _ = "checkHorizon.else"
                                                                                     in let failExp =
                                                                                              Data.Set.Internal.Bin
                                                                                                1
                                                                                                ( Symantic.Parser.Grammar.Combinators.SomeFailure
                                                                                                    ( case inputToken of
                                                                                                        (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 1
                                                                                                    )
                                                                                                )
                                                                                                Data.Set.Internal.Tip
                                                                                                Data.Set.Internal.Tip
                                                                                         in let (#
                                                                                                  farInp,
                                                                                                  farExp
                                                                                                  #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp failInp of
                                                                                                    GHC.Types.LT ->
                                                                                                      (#
                                                                                                        failInp,
                                                                                                        failExp
                                                                                                      #)
                                                                                                    GHC.Types.EQ ->
                                                                                                      (#
                                                                                                        farInp,
                                                                                                        failExp GHC.Base.<> farExp
                                                                                                      #)
                                                                                                    GHC.Types.GT ->
                                                                                                      (#
                                                                                                        farInp,
                                                                                                        farExp
                                                                                                      #)
                                                                                             in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp
                                                                    else
                                                                      let _ = "choicesBranch.else"
                                                                       in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp
                                                                loop = \_callReturn callInput callCatchStackByLabel ->
                                                                  name
                                                                    ( let _ = "suspend"
                                                                       in \farInp farExp v (!inp) -> do
                                                                            sr <- GHC.STRef.readSTRef reg
                                                                            do
                                                                              let dupv = sr
                                                                              GHC.STRef.writeSTRef reg dupv
                                                                              let _ = "jump"
                                                                               in loop (GHC.Err.error "invalid return") inp (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure (catchHandler callInput) Data.Map.Internal.Tip Data.Map.Internal.Tip)
                                                                    )
                                                                    callInput
                                                                    (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure (catchHandler callInput) Data.Map.Internal.Tip Data.Map.Internal.Tip)
                                                             in let _ = "jump"
                                                                 in loop callReturn inp (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure readFail Data.Map.Internal.Tip Data.Map.Internal.Tip)
                                                )
                                                inp
                                                (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure readFail Data.Map.Internal.Tip Data.Map.Internal.Tip)
                                      )
                                      cs
                                      (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure readFail Data.Map.Internal.Tip Data.Map.Internal.Tip)
                                  else
                                    let _ = "checkToken.else"
                                     in let failExp =
                                              Data.Set.Internal.Bin
                                                1
                                                ( Symantic.Parser.Grammar.Combinators.SomeFailure
                                                    ( case inputToken of
                                                        (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken '['
                                                    )
                                                )
                                                Data.Set.Internal.Tip
                                                Data.Set.Internal.Tip
                                         in let (#
                                                  farInp,
                                                  farExp
                                                  #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init callInput of
                                                    GHC.Types.LT ->
                                                      (#
                                                        callInput,
                                                        failExp
                                                      #)
                                                    GHC.Types.EQ ->
                                                      (#
                                                        init,
                                                        failExp GHC.Base.<> Data.Set.Internal.empty
                                                      #)
                                                    GHC.Types.GT ->
                                                      (#
                                                        init,
                                                        Data.Set.Internal.empty
                                                      #)
                                             in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure callInput farInp farExp
                          else
                            let _ = "checkHorizon.else"
                             in let failExp =
                                      Data.Set.Internal.Bin
                                        1
                                        ( Symantic.Parser.Grammar.Combinators.SomeFailure
                                            ( case inputToken of
                                                (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 5
                                            )
                                        )
                                        Data.Set.Internal.Tip
                                        Data.Set.Internal.Tip
                                 in let (#
                                          farInp,
                                          farExp
                                          #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init callInput of
                                            GHC.Types.LT ->
                                              (#
                                                callInput,
                                                failExp
                                              #)
                                            GHC.Types.EQ ->
                                              (#
                                                init,
                                                failExp GHC.Base.<> Data.Set.Internal.empty
                                              #)
                                            GHC.Types.GT ->
                                              (#
                                                init,
                                                Data.Set.Internal.empty
                                              #)
                                     in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure callInput farInp farExp
                  name = \(!callReturn) (!callInput) (!callCatchStackByLabel) ->
                    let _ = "catch ExceptionFailure"
                     in let catchHandler (!_exn) (!failInp) (!farInp) (!farExp) =
                              let _ = "catch.ko ExceptionFailure"
                               in Data.Map.Strict.Internal.findWithDefault finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure callCatchStackByLabel Symantic.Parser.Grammar.Combinators.ExceptionFailure callInput farInp farExp
                         in let readFail = catchHandler
                             in if readMore (Symantic.Parser.Machine.Input.shiftRightText 1 callInput)
                                  then
                                    let !(#
                                           c,
                                           cs
                                           #) = readNext callInput
                                     in if Parsers.Nandlang.nandIdentStart c
                                          then do
                                            let dupv = \x -> x
                                            reg <- GHC.STRef.newSTRef dupv
                                            let _ = "iter"
                                             in let catchHandler loopInput (!_exn) (!failInp) (!farInp) (!farExp) =
                                                      if ( \( Data.Text.Internal.Text
                                                                _
                                                                i
                                                                _
                                                              )
                                                            ( Data.Text.Internal.Text
                                                                _
                                                                j
                                                                _
                                                              ) -> i GHC.Classes.== j
                                                         )
                                                        loopInput
                                                        failInp
                                                        then
                                                          let _ = "choicesBranch.then"
                                                           in do
                                                                sr <- GHC.STRef.readSTRef reg
                                                                name
                                                                  ( let _ = "suspend"
                                                                     in \farInp farExp v (!inp) ->
                                                                          name
                                                                            ( let _ = "suspend"
                                                                               in \farInp farExp v (!inp) ->
                                                                                    name
                                                                                      ( let _ = "suspend"
                                                                                         in \farInp farExp v (!inp) ->
                                                                                              let _ = "resume"
                                                                                               in callReturn
                                                                                                    farInp
                                                                                                    farExp
                                                                                                    ( let _ = "resume.genCode"
                                                                                                       in v
                                                                                                    )
                                                                                                    inp
                                                                                      )
                                                                                      inp
                                                                                      (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure (Data.Map.Strict.Internal.findWithDefault finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure callCatchStackByLabel) Data.Map.Internal.Tip Data.Map.Internal.Tip)
                                                                            )
                                                                            inp
                                                                            Data.Map.Internal.Tip
                                                                  )
                                                                  failInp
                                                                  Data.Map.Internal.Tip
                                                        else
                                                          let _ = "choicesBranch.else"
                                                           in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp
                                                    loop = \_callReturn callInput callCatchStackByLabel ->
                                                      let readFail = catchHandler callInput
                                                       in if readMore (Symantic.Parser.Machine.Input.shiftRightText 2 callInput)
                                                            then
                                                              let !(#
                                                                     c,
                                                                     cs
                                                                     #) = readNext callInput
                                                               in if Parsers.Nandlang.nandIdentLetter c
                                                                    then do
                                                                      sr <- GHC.STRef.readSTRef reg
                                                                      do
                                                                        let dupv = sr
                                                                        GHC.STRef.writeSTRef reg dupv
                                                                        let _ = "jump"
                                                                         in loop (GHC.Err.error "invalid return") cs (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure readFail Data.Map.Internal.Tip Data.Map.Internal.Tip)
                                                                    else
                                                                      let _ = "checkToken.else"
                                                                       in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure callInput init Data.Set.Internal.empty
                                                            else
                                                              let _ = "checkHorizon.else"
                                                               in let failExp =
                                                                        Data.Set.Internal.Bin
                                                                          1
                                                                          ( Symantic.Parser.Grammar.Combinators.SomeFailure
                                                                              ( case inputToken of
                                                                                  (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 3
                                                                              )
                                                                          )
                                                                          Data.Set.Internal.Tip
                                                                          Data.Set.Internal.Tip
                                                                   in let (#
                                                                            farInp,
                                                                            farExp
                                                                            #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init callInput of
                                                                              GHC.Types.LT ->
                                                                                (#
                                                                                  callInput,
                                                                                  failExp
                                                                                #)
                                                                              GHC.Types.EQ ->
                                                                                (#
                                                                                  init,
                                                                                  failExp GHC.Base.<> Data.Set.Internal.empty
                                                                                #)
                                                                              GHC.Types.GT ->
                                                                                (#
                                                                                  init,
                                                                                  Data.Set.Internal.empty
                                                                                #)
                                                                       in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure callInput farInp farExp
                                                 in let _ = "jump"
                                                     in loop callReturn cs (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure readFail Data.Map.Internal.Tip Data.Map.Internal.Tip)
                                          else
                                            let _ = "checkToken.else"
                                             in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure callInput init Data.Set.Internal.empty
                                  else
                                    let _ = "checkHorizon.else"
                                     in let failExp =
                                              Data.Set.Internal.Bin
                                                1
                                                ( Symantic.Parser.Grammar.Combinators.SomeFailure
                                                    ( case inputToken of
                                                        (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 2
                                                    )
                                                )
                                                Data.Set.Internal.Tip
                                                Data.Set.Internal.Tip
                                         in let (#
                                                  farInp,
                                                  farExp
                                                  #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init callInput of
                                                    GHC.Types.LT ->
                                                      (#
                                                        callInput,
                                                        failExp
                                                      #)
                                                    GHC.Types.EQ ->
                                                      (#
                                                        init,
                                                        failExp GHC.Base.<> Data.Set.Internal.empty
                                                      #)
                                                    GHC.Types.GT ->
                                                      (#
                                                        init,
                                                        Data.Set.Internal.empty
                                                      #)
                                             in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure callInput farInp farExp
                  name = \(!callReturn) (!callInput) (!callCatchStackByLabel) ->
                    let _ = "catch ExceptionFailure"
                     in let catchHandler (!_exn) (!failInp) (!farInp) (!farExp) =
                              let _ = "catch.ko ExceptionFailure"
                               in if ( \( Data.Text.Internal.Text
                                            _
                                            i
                                            _
                                          )
                                        ( Data.Text.Internal.Text
                                            _
                                            j
                                            _
                                          ) -> i GHC.Classes.== j
                                     )
                                    callInput
                                    failInp
                                    then
                                      let _ = "choicesBranch.then"
                                       in let _ = "catch ExceptionFailure"
                                           in let catchHandler (!_exn) (!failInp) (!farInp) (!farExp) =
                                                    let _ = "catch.ko ExceptionFailure"
                                                     in if ( \( Data.Text.Internal.Text
                                                                  _
                                                                  i
                                                                  _
                                                                )
                                                              ( Data.Text.Internal.Text
                                                                  _
                                                                  j
                                                                  _
                                                                ) -> i GHC.Classes.== j
                                                           )
                                                          failInp
                                                          failInp
                                                          then
                                                            let _ = "choicesBranch.then"
                                                             in name
                                                                  ( let _ = "suspend"
                                                                     in \farInp farExp v (!inp) ->
                                                                          let join = \farInp farExp v (!inp) ->
                                                                                let _ = "resume"
                                                                                 in callReturn
                                                                                      farInp
                                                                                      farExp
                                                                                      ( let _ = "resume.genCode"
                                                                                         in v
                                                                                      )
                                                                                      inp
                                                                           in let _ = "catch ExceptionFailure"
                                                                               in let catchHandler (!_exn) (!failInp) (!farInp) (!farExp) =
                                                                                        let _ = "catch.ko ExceptionFailure"
                                                                                         in if ( \( Data.Text.Internal.Text
                                                                                                      _
                                                                                                      i
                                                                                                      _
                                                                                                    )
                                                                                                  ( Data.Text.Internal.Text
                                                                                                      _
                                                                                                      j
                                                                                                      _
                                                                                                    ) -> i GHC.Classes.== j
                                                                                               )
                                                                                              inp
                                                                                              failInp
                                                                                              then
                                                                                                let _ = "choicesBranch.then"
                                                                                                 in name
                                                                                                      ( let _ = "suspend"
                                                                                                         in \farInp farExp v (!inp) ->
                                                                                                              let _ = "resume"
                                                                                                               in join
                                                                                                                    farInp
                                                                                                                    farExp
                                                                                                                    ( let _ = "resume.genCode"
                                                                                                                       in v
                                                                                                                    )
                                                                                                                    inp
                                                                                                      )
                                                                                                      failInp
                                                                                                      Data.Map.Internal.Tip
                                                                                              else
                                                                                                let _ = "choicesBranch.else"
                                                                                                 in Data.Map.Strict.Internal.findWithDefault finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure callCatchStackByLabel Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp
                                                                                   in let join = \farInp farExp v (!inp) ->
                                                                                            let _ = "resume"
                                                                                             in join
                                                                                                  farInp
                                                                                                  farExp
                                                                                                  ( let _ = "resume.genCode"
                                                                                                     in GHC.Tuple . ()
                                                                                                  )
                                                                                                  inp
                                                                                       in let _ = "catch ExceptionFailure"
                                                                                           in let catchHandler (!_exn) (!failInp) (!farInp) (!farExp) =
                                                                                                    let _ = "catch.ko ExceptionFailure"
                                                                                                     in if ( \( Data.Text.Internal.Text
                                                                                                                  _
                                                                                                                  i
                                                                                                                  _
                                                                                                                )
                                                                                                              ( Data.Text.Internal.Text
                                                                                                                  _
                                                                                                                  j
                                                                                                                  _
                                                                                                                ) -> i GHC.Classes.== j
                                                                                                           )
                                                                                                          inp
                                                                                                          failInp
                                                                                                          then
                                                                                                            let _ = "choicesBranch.then"
                                                                                                             in name
                                                                                                                  ( let _ = "suspend"
                                                                                                                     in \farInp farExp v (!inp) ->
                                                                                                                          let _ = "resume"
                                                                                                                           in join
                                                                                                                                farInp
                                                                                                                                farExp
                                                                                                                                ( let _ = "resume.genCode"
                                                                                                                                   in v
                                                                                                                                )
                                                                                                                                inp
                                                                                                                  )
                                                                                                                  failInp
                                                                                                                  (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure catchHandler Data.Map.Internal.Tip Data.Map.Internal.Tip)
                                                                                                          else
                                                                                                            let _ = "choicesBranch.else"
                                                                                                             in catchHandler Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp
                                                                                               in name
                                                                                                    ( let _ = "suspend"
                                                                                                       in \farInp farExp v (!inp) ->
                                                                                                            let join = \farInp farExp v (!inp) ->
                                                                                                                  name
                                                                                                                    ( let _ = "suspend"
                                                                                                                       in \farInp farExp v (!inp) ->
                                                                                                                            let _ = "resume"
                                                                                                                             in join
                                                                                                                                  farInp
                                                                                                                                  farExp
                                                                                                                                  ( let _ = "resume.genCode"
                                                                                                                                     in v
                                                                                                                                  )
                                                                                                                                  inp
                                                                                                                    )
                                                                                                                    inp
                                                                                                                    (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure catchHandler Data.Map.Internal.Tip Data.Map.Internal.Tip)
                                                                                                             in let _ = "catch ExceptionFailure"
                                                                                                                 in let catchHandler (!_exn) (!failInp) (!farInp) (!farExp) =
                                                                                                                          let _ = "catch.ko ExceptionFailure"
                                                                                                                           in if ( \( Data.Text.Internal.Text
                                                                                                                                        _
                                                                                                                                        i
                                                                                                                                        _
                                                                                                                                      )
                                                                                                                                    ( Data.Text.Internal.Text
                                                                                                                                        _
                                                                                                                                        j
                                                                                                                                        _
                                                                                                                                      ) -> i GHC.Classes.== j
                                                                                                                                 )
                                                                                                                                inp
                                                                                                                                failInp
                                                                                                                                then
                                                                                                                                  let _ = "choicesBranch.then"
                                                                                                                                   in name
                                                                                                                                        ( let _ = "suspend"
                                                                                                                                           in \farInp farExp v (!inp) ->
                                                                                                                                                let _ = "resume"
                                                                                                                                                 in join
                                                                                                                                                      farInp
                                                                                                                                                      farExp
                                                                                                                                                      ( let _ = "resume.genCode"
                                                                                                                                                         in v
                                                                                                                                                      )
                                                                                                                                                      inp
                                                                                                                                        )
                                                                                                                                        failInp
                                                                                                                                        Data.Map.Internal.Tip
                                                                                                                                else
                                                                                                                                  let _ = "choicesBranch.else"
                                                                                                                                   in catchHandler Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp
                                                                                                                     in name
                                                                                                                          ( let _ = "suspend"
                                                                                                                             in \farInp farExp v (!inp) -> do
                                                                                                                                  let dupv = \x -> x
                                                                                                                                  reg <- GHC.STRef.newSTRef dupv
                                                                                                                                  let _ = "iter"
                                                                                                                                   in let catchHandler loopInput (!_exn) (!failInp) (!farInp) (!farExp) =
                                                                                                                                            if ( \( Data.Text.Internal.Text
                                                                                                                                                      _
                                                                                                                                                      i
                                                                                                                                                      _
                                                                                                                                                    )
                                                                                                                                                  ( Data.Text.Internal.Text
                                                                                                                                                      _
                                                                                                                                                      j
                                                                                                                                                      _
                                                                                                                                                    ) -> i GHC.Classes.== j
                                                                                                                                               )
                                                                                                                                              loopInput
                                                                                                                                              failInp
                                                                                                                                              then
                                                                                                                                                let _ = "choicesBranch.then"
                                                                                                                                                 in do
                                                                                                                                                      sr <- GHC.STRef.readSTRef reg
                                                                                                                                                      name
                                                                                                                                                        ( let _ = "suspend"
                                                                                                                                                           in \farInp farExp v (!inp) ->
                                                                                                                                                                name
                                                                                                                                                                  ( let _ = "suspend"
                                                                                                                                                                     in \farInp farExp v (!inp) ->
                                                                                                                                                                          let _ = "resume"
                                                                                                                                                                           in join
                                                                                                                                                                                farInp
                                                                                                                                                                                farExp
                                                                                                                                                                                ( let _ = "resume.genCode"
                                                                                                                                                                                   in GHC.Tuple . ()
                                                                                                                                                                                )
                                                                                                                                                                                inp
                                                                                                                                                                  )
                                                                                                                                                                  inp
                                                                                                                                                                  Data.Map.Internal.Tip
                                                                                                                                                        )
                                                                                                                                                        failInp
                                                                                                                                                        Data.Map.Internal.Tip
                                                                                                                                              else
                                                                                                                                                let _ = "choicesBranch.else"
                                                                                                                                                 in catchHandler Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp
                                                                                                                                          loop = \_callReturn callInput callCatchStackByLabel ->
                                                                                                                                            name
                                                                                                                                              ( let _ = "suspend"
                                                                                                                                                 in \farInp farExp v (!inp) ->
                                                                                                                                                      name
                                                                                                                                                        ( let _ = "suspend"
                                                                                                                                                           in \farInp farExp v (!inp) ->
                                                                                                                                                                name
                                                                                                                                                                  ( let _ = "suspend"
                                                                                                                                                                     in \farInp farExp v (!inp) -> do
                                                                                                                                                                          sr <- GHC.STRef.readSTRef reg
                                                                                                                                                                          do
                                                                                                                                                                            let dupv = v v sr
                                                                                                                                                                            GHC.STRef.writeSTRef reg dupv
                                                                                                                                                                            let _ = "jump"
                                                                                                                                                                             in loop (GHC.Err.error "invalid return") inp (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure (catchHandler callInput) Data.Map.Internal.Tip Data.Map.Internal.Tip)
                                                                                                                                                                  )
                                                                                                                                                                  inp
                                                                                                                                                                  (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure (catchHandler callInput) Data.Map.Internal.Tip Data.Map.Internal.Tip)
                                                                                                                                                        )
                                                                                                                                                        inp
                                                                                                                                                        (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure (catchHandler callInput) Data.Map.Internal.Tip Data.Map.Internal.Tip)
                                                                                                                                              )
                                                                                                                                              callInput
                                                                                                                                              Data.Map.Internal.Tip
                                                                                                                                       in let _ = "jump"
                                                                                                                                           in loop callReturn inp (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure catchHandler Data.Map.Internal.Tip Data.Map.Internal.Tip)
                                                                                                                          )
                                                                                                                          inp
                                                                                                                          (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure catchHandler Data.Map.Internal.Tip Data.Map.Internal.Tip)
                                                                                                    )
                                                                                                    inp
                                                                                                    (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure catchHandler Data.Map.Internal.Tip Data.Map.Internal.Tip)
                                                                  )
                                                                  failInp
                                                                  (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure (Data.Map.Strict.Internal.findWithDefault finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure callCatchStackByLabel) Data.Map.Internal.Tip Data.Map.Internal.Tip)
                                                          else
                                                            let _ = "choicesBranch.else"
                                                             in Data.Map.Strict.Internal.findWithDefault finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure callCatchStackByLabel Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp
                                               in let readFail = catchHandler
                                                   in if readMore (Symantic.Parser.Machine.Input.shiftRightText 3 failInp)
                                                        then
                                                          let !(#
                                                                 c,
                                                                 cs
                                                                 #) = readNext failInp
                                                           in if (GHC.Classes.==) '\'' c
                                                                then
                                                                  let join = \farInp farExp v (!inp) ->
                                                                        let readFail = readFail
                                                                         in if readMore (Symantic.Parser.Machine.Input.shiftRightText 1 inp)
                                                                              then
                                                                                let !(#
                                                                                       c,
                                                                                       cs
                                                                                       #) = readNext inp
                                                                                 in if (GHC.Classes.==) '\'' c
                                                                                      then
                                                                                        name
                                                                                          ( let _ = "suspend"
                                                                                             in \farInp farExp v (!inp) ->
                                                                                                  let _ = "resume"
                                                                                                   in callReturn
                                                                                                        farInp
                                                                                                        farExp
                                                                                                        ( let _ = "resume.genCode"
                                                                                                           in v
                                                                                                        )
                                                                                                        inp
                                                                                          )
                                                                                          cs
                                                                                          (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure readFail Data.Map.Internal.Tip Data.Map.Internal.Tip)
                                                                                      else
                                                                                        let _ = "checkToken.else"
                                                                                         in let failExp =
                                                                                                  Data.Set.Internal.Bin
                                                                                                    1
                                                                                                    ( Symantic.Parser.Grammar.Combinators.SomeFailure
                                                                                                        ( case inputToken of
                                                                                                            (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken '\''
                                                                                                        )
                                                                                                    )
                                                                                                    Data.Set.Internal.Tip
                                                                                                    Data.Set.Internal.Tip
                                                                                             in let (#
                                                                                                      farInp,
                                                                                                      farExp
                                                                                                      #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp inp of
                                                                                                        GHC.Types.LT ->
                                                                                                          (#
                                                                                                            inp,
                                                                                                            failExp
                                                                                                          #)
                                                                                                        GHC.Types.EQ ->
                                                                                                          (#
                                                                                                            farInp,
                                                                                                            failExp GHC.Base.<> farExp
                                                                                                          #)
                                                                                                        GHC.Types.GT ->
                                                                                                          (#
                                                                                                            farInp,
                                                                                                            farExp
                                                                                                          #)
                                                                                                 in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp
                                                                              else
                                                                                let _ = "checkHorizon.else"
                                                                                 in let failExp =
                                                                                          Data.Set.Internal.Bin
                                                                                            1
                                                                                            ( Symantic.Parser.Grammar.Combinators.SomeFailure
                                                                                                ( case inputToken of
                                                                                                    (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 2
                                                                                                )
                                                                                            )
                                                                                            Data.Set.Internal.Tip
                                                                                            Data.Set.Internal.Tip
                                                                                     in let (#
                                                                                              farInp,
                                                                                              farExp
                                                                                              #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp inp of
                                                                                                GHC.Types.LT ->
                                                                                                  (#
                                                                                                    inp,
                                                                                                    failExp
                                                                                                  #)
                                                                                                GHC.Types.EQ ->
                                                                                                  (#
                                                                                                    farInp,
                                                                                                    failExp GHC.Base.<> farExp
                                                                                                  #)
                                                                                                GHC.Types.GT ->
                                                                                                  (#
                                                                                                    farInp,
                                                                                                    farExp
                                                                                                  #)
                                                                                         in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp
                                                                   in let _ = "catch ExceptionFailure"
                                                                       in let catchHandler (!_exn) (!failInp) (!farInp) (!farExp) =
                                                                                let _ = "catch.ko ExceptionFailure"
                                                                                 in if ( \( Data.Text.Internal.Text
                                                                                              _
                                                                                              i
                                                                                              _
                                                                                            )
                                                                                          ( Data.Text.Internal.Text
                                                                                              _
                                                                                              j
                                                                                              _
                                                                                            ) -> i GHC.Classes.== j
                                                                                       )
                                                                                      cs
                                                                                      failInp
                                                                                      then
                                                                                        let _ = "choicesBranch.then"
                                                                                         in let readFail = readFail
                                                                                             in if readMore (Symantic.Parser.Machine.Input.shiftRightText 3 failInp)
                                                                                                  then
                                                                                                    let !(#
                                                                                                           c,
                                                                                                           cs
                                                                                                           #) = readNext failInp
                                                                                                     in if (GHC.Classes.==) '\\' c
                                                                                                          then
                                                                                                            let readFail = readFail
                                                                                                             in let !(#
                                                                                                                       c,
                                                                                                                       cs
                                                                                                                       #) = readNext cs
                                                                                                                 in if (\t -> ('0' GHC.Classes.== t) GHC.Classes.|| (('t' GHC.Classes.== t) GHC.Classes.|| (('n' GHC.Classes.== t) GHC.Classes.|| (('v' GHC.Classes.== t) GHC.Classes.|| (('f' GHC.Classes.== t) GHC.Classes.|| (('r' GHC.Classes.== t) GHC.Classes.|| GHC.Types.False)))))) c
                                                                                                                      then
                                                                                                                        name
                                                                                                                          ( let _ = "suspend"
                                                                                                                             in \farInp farExp v (!inp) ->
                                                                                                                                  let _ = "resume"
                                                                                                                                   in join
                                                                                                                                        farInp
                                                                                                                                        farExp
                                                                                                                                        ( let _ = "resume.genCode"
                                                                                                                                           in v
                                                                                                                                        )
                                                                                                                                        inp
                                                                                                                          )
                                                                                                                          cs
                                                                                                                          Data.Map.Internal.Tip
                                                                                                                      else
                                                                                                                        let _ = "checkToken.else"
                                                                                                                         in let failExp =
                                                                                                                                  Data.Set.Internal.Bin
                                                                                                                                    6
                                                                                                                                    ( Symantic.Parser.Grammar.Combinators.SomeFailure
                                                                                                                                        ( case inputToken of
                                                                                                                                            (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'n'
                                                                                                                                        )
                                                                                                                                    )
                                                                                                                                    ( Data.Set.Internal.Bin
                                                                                                                                        2
                                                                                                                                        ( Symantic.Parser.Grammar.Combinators.SomeFailure
                                                                                                                                            ( case inputToken of
                                                                                                                                                (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken '0'
                                                                                                                                            )
                                                                                                                                        )
                                                                                                                                        Data.Set.Internal.Tip
                                                                                                                                        ( Data.Set.Internal.Bin
                                                                                                                                            1
                                                                                                                                            ( Symantic.Parser.Grammar.Combinators.SomeFailure
                                                                                                                                                ( case inputToken of
                                                                                                                                                    (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'f'
                                                                                                                                                )
                                                                                                                                            )
                                                                                                                                            Data.Set.Internal.Tip
                                                                                                                                            Data.Set.Internal.Tip
                                                                                                                                        )
                                                                                                                                    )
                                                                                                                                    ( Data.Set.Internal.Bin
                                                                                                                                        3
                                                                                                                                        ( Symantic.Parser.Grammar.Combinators.SomeFailure
                                                                                                                                            ( case inputToken of
                                                                                                                                                (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 't'
                                                                                                                                            )
                                                                                                                                        )
                                                                                                                                        ( Data.Set.Internal.Bin
                                                                                                                                            1
                                                                                                                                            ( Symantic.Parser.Grammar.Combinators.SomeFailure
                                                                                                                                                ( case inputToken of
                                                                                                                                                    (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'r'
                                                                                                                                                )
                                                                                                                                            )
                                                                                                                                            Data.Set.Internal.Tip
                                                                                                                                            Data.Set.Internal.Tip
                                                                                                                                        )
                                                                                                                                        ( Data.Set.Internal.Bin
                                                                                                                                            1
                                                                                                                                            ( Symantic.Parser.Grammar.Combinators.SomeFailure
                                                                                                                                                ( case inputToken of
                                                                                                                                                    (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'v'
                                                                                                                                                )
                                                                                                                                            )
                                                                                                                                            Data.Set.Internal.Tip
                                                                                                                                            Data.Set.Internal.Tip
                                                                                                                                        )
                                                                                                                                    )
                                                                                                                             in let (#
                                                                                                                                      farInp,
                                                                                                                                      farExp
                                                                                                                                      #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp cs of
                                                                                                                                        GHC.Types.LT ->
                                                                                                                                          (#
                                                                                                                                            cs,
                                                                                                                                            failExp
                                                                                                                                          #)
                                                                                                                                        GHC.Types.EQ ->
                                                                                                                                          (#
                                                                                                                                            farInp,
                                                                                                                                            failExp GHC.Base.<> farExp
                                                                                                                                          #)
                                                                                                                                        GHC.Types.GT ->
                                                                                                                                          (#
                                                                                                                                            farInp,
                                                                                                                                            farExp
                                                                                                                                          #)
                                                                                                                                 in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure cs farInp farExp
                                                                                                          else
                                                                                                            let _ = "checkToken.else"
                                                                                                             in let failExp =
                                                                                                                      Data.Set.Internal.Bin
                                                                                                                        1
                                                                                                                        ( Symantic.Parser.Grammar.Combinators.SomeFailure
                                                                                                                            ( case inputToken of
                                                                                                                                (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken '\\'
                                                                                                                            )
                                                                                                                        )
                                                                                                                        Data.Set.Internal.Tip
                                                                                                                        Data.Set.Internal.Tip
                                                                                                                 in let (#
                                                                                                                          farInp,
                                                                                                                          farExp
                                                                                                                          #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp failInp of
                                                                                                                            GHC.Types.LT ->
                                                                                                                              (#
                                                                                                                                failInp,
                                                                                                                                failExp
                                                                                                                              #)
                                                                                                                            GHC.Types.EQ ->
                                                                                                                              (#
                                                                                                                                farInp,
                                                                                                                                failExp GHC.Base.<> farExp
                                                                                                                              #)
                                                                                                                            GHC.Types.GT ->
                                                                                                                              (#
                                                                                                                                farInp,
                                                                                                                                farExp
                                                                                                                              #)
                                                                                                                     in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp
                                                                                                  else
                                                                                                    let _ = "checkHorizon.else"
                                                                                                     in let failExp =
                                                                                                              Data.Set.Internal.Bin
                                                                                                                1
                                                                                                                ( Symantic.Parser.Grammar.Combinators.SomeFailure
                                                                                                                    ( case inputToken of
                                                                                                                        (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 4
                                                                                                                    )
                                                                                                                )
                                                                                                                Data.Set.Internal.Tip
                                                                                                                Data.Set.Internal.Tip
                                                                                                         in let (#
                                                                                                                  farInp,
                                                                                                                  farExp
                                                                                                                  #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp failInp of
                                                                                                                    GHC.Types.LT ->
                                                                                                                      (#
                                                                                                                        failInp,
                                                                                                                        failExp
                                                                                                                      #)
                                                                                                                    GHC.Types.EQ ->
                                                                                                                      (#
                                                                                                                        farInp,
                                                                                                                        failExp GHC.Base.<> farExp
                                                                                                                      #)
                                                                                                                    GHC.Types.GT ->
                                                                                                                      (#
                                                                                                                        farInp,
                                                                                                                        farExp
                                                                                                                      #)
                                                                                                             in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp
                                                                                      else
                                                                                        let _ = "choicesBranch.else"
                                                                                         in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp
                                                                           in let readFail = catchHandler
                                                                               in let !(#
                                                                                         c,
                                                                                         cs
                                                                                         #) = readNext cs
                                                                                   in if Parsers.Nandlang.nandStringLetter c
                                                                                        then
                                                                                          name
                                                                                            ( let _ = "suspend"
                                                                                               in \farInp farExp v (!inp) ->
                                                                                                    let _ = "resume"
                                                                                                     in join
                                                                                                          farInp
                                                                                                          farExp
                                                                                                          ( let _ = "resume.genCode"
                                                                                                             in v
                                                                                                          )
                                                                                                          inp
                                                                                            )
                                                                                            cs
                                                                                            Data.Map.Internal.Tip
                                                                                        else
                                                                                          let _ = "checkToken.else"
                                                                                           in catchHandler Symantic.Parser.Grammar.Combinators.ExceptionFailure cs farInp farExp
                                                                else
                                                                  let _ = "checkToken.else"
                                                                   in let failExp =
                                                                            Data.Set.Internal.Bin
                                                                              1
                                                                              ( Symantic.Parser.Grammar.Combinators.SomeFailure
                                                                                  ( case inputToken of
                                                                                      (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken '\''
                                                                                  )
                                                                              )
                                                                              Data.Set.Internal.Tip
                                                                              Data.Set.Internal.Tip
                                                                       in let (#
                                                                                farInp,
                                                                                farExp
                                                                                #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp failInp of
                                                                                  GHC.Types.LT ->
                                                                                    (#
                                                                                      failInp,
                                                                                      failExp
                                                                                    #)
                                                                                  GHC.Types.EQ ->
                                                                                    (#
                                                                                      farInp,
                                                                                      failExp GHC.Base.<> farExp
                                                                                    #)
                                                                                  GHC.Types.GT ->
                                                                                    (#
                                                                                      farInp,
                                                                                      farExp
                                                                                    #)
                                                                           in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp
                                                        else
                                                          let _ = "checkHorizon.else"
                                                           in let failExp =
                                                                    Data.Set.Internal.Bin
                                                                      1
                                                                      ( Symantic.Parser.Grammar.Combinators.SomeFailure
                                                                          ( case inputToken of
                                                                              (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 4
                                                                          )
                                                                      )
                                                                      Data.Set.Internal.Tip
                                                                      Data.Set.Internal.Tip
                                                               in let (#
                                                                        farInp,
                                                                        farExp
                                                                        #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp failInp of
                                                                          GHC.Types.LT ->
                                                                            (#
                                                                              failInp,
                                                                              failExp
                                                                            #)
                                                                          GHC.Types.EQ ->
                                                                            (#
                                                                              farInp,
                                                                              failExp GHC.Base.<> farExp
                                                                            #)
                                                                          GHC.Types.GT ->
                                                                            (#
                                                                              farInp,
                                                                              farExp
                                                                            #)
                                                                   in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp
                                    else
                                      let _ = "choicesBranch.else"
                                       in Data.Map.Strict.Internal.findWithDefault finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure callCatchStackByLabel Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp
                         in let join = \farInp farExp v (!inp) ->
                                  name
                                    ( let _ = "suspend"
                                       in \farInp farExp v (!inp) ->
                                            let _ = "resume"
                                             in callReturn
                                                  farInp
                                                  farExp
                                                  ( let _ = "resume.genCode"
                                                     in v
                                                  )
                                                  inp
                                    )
                                    inp
                                    (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure catchHandler Data.Map.Internal.Tip Data.Map.Internal.Tip)
                             in let _ = "catch ExceptionFailure"
                                 in let catchHandler (!_exn) (!failInp) (!farInp) (!farExp) =
                                          let _ = "catch.ko ExceptionFailure"
                                           in if ( \( Data.Text.Internal.Text
                                                        _
                                                        i
                                                        _
                                                      )
                                                    ( Data.Text.Internal.Text
                                                        _
                                                        j
                                                        _
                                                      ) -> i GHC.Classes.== j
                                                 )
                                                callInput
                                                failInp
                                                then
                                                  let _ = "choicesBranch.then"
                                                   in let readFail = catchHandler
                                                       in if readMore (Symantic.Parser.Machine.Input.shiftRightText 1 failInp)
                                                            then
                                                              let !(#
                                                                     c,
                                                                     cs
                                                                     #) = readNext failInp
                                                               in if (GHC.Classes.==) '1' c
                                                                    then
                                                                      let _ = "resume"
                                                                       in join
                                                                            farInp
                                                                            farExp
                                                                            ( let _ = "resume.genCode"
                                                                               in '1'
                                                                            )
                                                                            cs
                                                                    else
                                                                      let _ = "checkToken.else"
                                                                       in let failExp =
                                                                                Data.Set.Internal.Bin
                                                                                  1
                                                                                  ( Symantic.Parser.Grammar.Combinators.SomeFailure
                                                                                      ( case inputToken of
                                                                                          (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken '1'
                                                                                      )
                                                                                  )
                                                                                  Data.Set.Internal.Tip
                                                                                  Data.Set.Internal.Tip
                                                                           in let (#
                                                                                    farInp,
                                                                                    farExp
                                                                                    #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp failInp of
                                                                                      GHC.Types.LT ->
                                                                                        (#
                                                                                          failInp,
                                                                                          failExp
                                                                                        #)
                                                                                      GHC.Types.EQ ->
                                                                                        (#
                                                                                          farInp,
                                                                                          failExp GHC.Base.<> farExp
                                                                                        #)
                                                                                      GHC.Types.GT ->
                                                                                        (#
                                                                                          farInp,
                                                                                          farExp
                                                                                        #)
                                                                               in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp
                                                            else
                                                              let _ = "checkHorizon.else"
                                                               in let failExp =
                                                                        Data.Set.Internal.Bin
                                                                          1
                                                                          ( Symantic.Parser.Grammar.Combinators.SomeFailure
                                                                              ( case inputToken of
                                                                                  (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 2
                                                                              )
                                                                          )
                                                                          Data.Set.Internal.Tip
                                                                          Data.Set.Internal.Tip
                                                                   in let (#
                                                                            farInp,
                                                                            farExp
                                                                            #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp failInp of
                                                                              GHC.Types.LT ->
                                                                                (#
                                                                                  failInp,
                                                                                  failExp
                                                                                #)
                                                                              GHC.Types.EQ ->
                                                                                (#
                                                                                  farInp,
                                                                                  failExp GHC.Base.<> farExp
                                                                                #)
                                                                              GHC.Types.GT ->
                                                                                (#
                                                                                  farInp,
                                                                                  farExp
                                                                                #)
                                                                       in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp
                                                else
                                                  let _ = "choicesBranch.else"
                                                   in catchHandler Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp
                                     in let readFail = catchHandler
                                         in if readMore (Symantic.Parser.Machine.Input.shiftRightText 1 callInput)
                                              then
                                                let !(#
                                                       c,
                                                       cs
                                                       #) = readNext callInput
                                                 in if (GHC.Classes.==) '0' c
                                                      then
                                                        let _ = "resume"
                                                         in join
                                                              init
                                                              Data.Set.Internal.empty
                                                              ( let _ = "resume.genCode"
                                                                 in '0'
                                                              )
                                                              cs
                                                      else
                                                        let _ = "checkToken.else"
                                                         in let failExp =
                                                                  Data.Set.Internal.Bin
                                                                    1
                                                                    ( Symantic.Parser.Grammar.Combinators.SomeFailure
                                                                        ( case inputToken of
                                                                            (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken '0'
                                                                        )
                                                                    )
                                                                    Data.Set.Internal.Tip
                                                                    Data.Set.Internal.Tip
                                                             in let (#
                                                                      farInp,
                                                                      farExp
                                                                      #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init callInput of
                                                                        GHC.Types.LT ->
                                                                          (#
                                                                            callInput,
                                                                            failExp
                                                                          #)
                                                                        GHC.Types.EQ ->
                                                                          (#
                                                                            init,
                                                                            failExp GHC.Base.<> Data.Set.Internal.empty
                                                                          #)
                                                                        GHC.Types.GT ->
                                                                          (#
                                                                            init,
                                                                            Data.Set.Internal.empty
                                                                          #)
                                                                 in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure callInput farInp farExp
                                              else
                                                let _ = "checkHorizon.else"
                                                 in let failExp =
                                                          Data.Set.Internal.Bin
                                                            1
                                                            ( Symantic.Parser.Grammar.Combinators.SomeFailure
                                                                ( case inputToken of
                                                                    (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 2
                                                                )
                                                            )
                                                            Data.Set.Internal.Tip
                                                            Data.Set.Internal.Tip
                                                     in let (#
                                                              farInp,
                                                              farExp
                                                              #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init callInput of
                                                                GHC.Types.LT ->
                                                                  (#
                                                                    callInput,
                                                                    failExp
                                                                  #)
                                                                GHC.Types.EQ ->
                                                                  (#
                                                                    init,
                                                                    failExp GHC.Base.<> Data.Set.Internal.empty
                                                                  #)
                                                                GHC.Types.GT ->
                                                                  (#
                                                                    init,
                                                                    Data.Set.Internal.empty
                                                                  #)
                                                         in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure callInput farInp farExp
                  name = \(!callReturn) (!callInput) (!callCatchStackByLabel) ->
                    let _ = "catch ExceptionFailure"
                     in let catchHandler (!_exn) (!failInp) (!farInp) (!farExp) =
                              let _ = "catch.ko ExceptionFailure"
                               in if ( \( Data.Text.Internal.Text
                                            _
                                            i
                                            _
                                          )
                                        ( Data.Text.Internal.Text
                                            _
                                            j
                                            _
                                          ) -> i GHC.Classes.== j
                                     )
                                    callInput
                                    failInp
                                    then
                                      let _ = "choicesBranch.then"
                                       in let _ = "jump"
                                           in name callReturn failInp Data.Map.Internal.Tip
                                    else
                                      let _ = "choicesBranch.else"
                                       in Data.Map.Strict.Internal.findWithDefault finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure callCatchStackByLabel Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp
                         in name
                              ( let _ = "suspend"
                                 in \farInp farExp v (!inp) -> do
                                      let dupv = \x -> x
                                      reg <- GHC.STRef.newSTRef dupv
                                      let _ = "iter"
                                       in let catchHandler loopInput (!_exn) (!failInp) (!farInp) (!farExp) =
                                                if ( \( Data.Text.Internal.Text
                                                          _
                                                          i
                                                          _
                                                        )
                                                      ( Data.Text.Internal.Text
                                                          _
                                                          j
                                                          _
                                                        ) -> i GHC.Classes.== j
                                                   )
                                                  loopInput
                                                  failInp
                                                  then
                                                    let _ = "choicesBranch.then"
                                                     in do
                                                          sr <- GHC.STRef.readSTRef reg
                                                          name
                                                            ( let _ = "suspend"
                                                               in \farInp farExp v (!inp) ->
                                                                    name
                                                                      ( let _ = "suspend"
                                                                         in \farInp farExp v (!inp) ->
                                                                              let _ = "resume"
                                                                               in callReturn
                                                                                    farInp
                                                                                    farExp
                                                                                    ( let _ = "resume.genCode"
                                                                                       in GHC.Tuple . ()
                                                                                    )
                                                                                    inp
                                                                      )
                                                                      inp
                                                                      Data.Map.Internal.Tip
                                                            )
                                                            failInp
                                                            Data.Map.Internal.Tip
                                                  else
                                                    let _ = "choicesBranch.else"
                                                     in catchHandler Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp
                                              loop = \_callReturn callInput callCatchStackByLabel ->
                                                name
                                                  ( let _ = "suspend"
                                                     in \farInp farExp v (!inp) ->
                                                          name
                                                            ( let _ = "suspend"
                                                               in \farInp farExp v (!inp) ->
                                                                    name
                                                                      ( let _ = "suspend"
                                                                         in \farInp farExp v (!inp) -> do
                                                                              sr <- GHC.STRef.readSTRef reg
                                                                              do
                                                                                let dupv = v v sr
                                                                                GHC.STRef.writeSTRef reg dupv
                                                                                let _ = "jump"
                                                                                 in loop (GHC.Err.error "invalid return") inp (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure (catchHandler callInput) Data.Map.Internal.Tip Data.Map.Internal.Tip)
                                                                      )
                                                                      inp
                                                                      (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure (catchHandler callInput) Data.Map.Internal.Tip Data.Map.Internal.Tip)
                                                            )
                                                            inp
                                                            (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure (catchHandler callInput) Data.Map.Internal.Tip Data.Map.Internal.Tip)
                                                  )
                                                  callInput
                                                  Data.Map.Internal.Tip
                                           in let _ = "jump"
                                               in loop callReturn inp (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure catchHandler Data.Map.Internal.Tip Data.Map.Internal.Tip)
                              )
                              callInput
                              (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure catchHandler Data.Map.Internal.Tip Data.Map.Internal.Tip)
                  name = \(!callReturn) (!callInput) (!callCatchStackByLabel) ->
                    let _ = "resume"
                     in callReturn
                          init
                          Data.Set.Internal.empty
                          ( let _ = "resume.genCode"
                             in GHC.Tuple . ()
                          )
                          callInput
                  name = \(!callReturn) (!callInput) (!callCatchStackByLabel) ->
                    let _ = "resume"
                     in callReturn
                          init
                          Data.Set.Internal.empty
                          ( let _ = "resume.genCode"
                             in GHC.Tuple . ()
                          )
                          callInput
                  name = \(!callReturn) (!callInput) (!callCatchStackByLabel) ->
                    let _ = "resume"
                     in callReturn
                          init
                          Data.Set.Internal.empty
                          ( let _ = "resume.genCode"
                             in \x -> \x -> x
                          )
                          callInput
               in name
                    ( let _ = "suspend"
                       in \farInp farExp v (!inp) -> do
                            let dupv = \x -> x
                            reg <- GHC.STRef.newSTRef dupv
                            let _ = "iter"
                             in let catchHandler loopInput (!_exn) (!failInp) (!farInp) (!farExp) =
                                      if ( \( Data.Text.Internal.Text
                                                _
                                                i
                                                _
                                              )
                                            ( Data.Text.Internal.Text
                                                _
                                                j
                                                _
                                              ) -> i GHC.Classes.== j
                                         )
                                        loopInput
                                        failInp
                                        then
                                          let _ = "choicesBranch.then"
                                           in do
                                                sr <- GHC.STRef.readSTRef reg
                                                name
                                                  ( let _ = "suspend"
                                                     in \farInp farExp v (!inp) ->
                                                          name
                                                            ( let _ = "suspend"
                                                               in \farInp farExp v (!inp) ->
                                                                    let join = \farInp farExp v (!inp) ->
                                                                          let _ = "resume"
                                                                           in finalRet
                                                                                farInp
                                                                                farExp
                                                                                ( let _ = "resume.genCode"
                                                                                   in GHC.Show.show v
                                                                                )
                                                                                inp
                                                                     in let _ = "catch ExceptionFailure"
                                                                         in let catchHandler (!_exn) (!failInp) (!farInp) (!farExp) =
                                                                                  let _ = "catch.ko ExceptionFailure"
                                                                                   in if ( \( Data.Text.Internal.Text
                                                                                                _
                                                                                                i
                                                                                                _
                                                                                              )
                                                                                            ( Data.Text.Internal.Text
                                                                                                _
                                                                                                j
                                                                                                _
                                                                                              ) -> i GHC.Classes.== j
                                                                                         )
                                                                                        inp
                                                                                        failInp
                                                                                        then
                                                                                          let _ = "choicesBranch.then"
                                                                                           in let failExp = 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,
                                                                                                        farExp
                                                                                                        #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp failInp of
                                                                                                          GHC.Types.LT ->
                                                                                                            (#
                                                                                                              failInp,
                                                                                                              failExp
                                                                                                            #)
                                                                                                          GHC.Types.EQ ->
                                                                                                            (#
                                                                                                              farInp,
                                                                                                              failExp GHC.Base.<> farExp
                                                                                                            #)
                                                                                                          GHC.Types.GT ->
                                                                                                            (#
                                                                                                              farInp,
                                                                                                              farExp
                                                                                                            #)
                                                                                                   in finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp
                                                                                        else
                                                                                          let _ = "choicesBranch.else"
                                                                                           in finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp
                                                                             in let _ = "catch ExceptionFailure"
                                                                                 in let catchHandler (!_exn) (!failInp) (!farInp) (!farExp) =
                                                                                          let _ = "catch.ko ExceptionFailure"
                                                                                           in let _ = "resume"
                                                                                               in join
                                                                                                    farInp
                                                                                                    farExp
                                                                                                    ( let _ = "resume.genCode"
                                                                                                       in GHC.Tuple . ()
                                                                                                    )
                                                                                                    inp
                                                                                     in let readFail = catchHandler
                                                                                         in if readMore inp
                                                                                              then
                                                                                                let !(#
                                                                                                       c,
                                                                                                       cs
                                                                                                       #) = readNext inp
                                                                                                 in catchHandler Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp
                                                                                              else
                                                                                                let _ = "checkHorizon.else"
                                                                                                 in let failExp =
                                                                                                          Data.Set.Internal.Bin
                                                                                                            1
                                                                                                            ( Symantic.Parser.Grammar.Combinators.SomeFailure
                                                                                                                ( case inputToken of
                                                                                                                    (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 1
                                                                                                                )
                                                                                                            )
                                                                                                            Data.Set.Internal.Tip
                                                                                                            Data.Set.Internal.Tip
                                                                                                     in let (#
                                                                                                              farInp,
                                                                                                              farExp
                                                                                                              #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp inp of
                                                                                                                GHC.Types.LT ->
                                                                                                                  (#
                                                                                                                    inp,
                                                                                                                    failExp
                                                                                                                  #)
                                                                                                                GHC.Types.EQ ->
                                                                                                                  (#
                                                                                                                    farInp,
                                                                                                                    failExp GHC.Base.<> farExp
                                                                                                                  #)
                                                                                                                GHC.Types.GT ->
                                                                                                                  (#
                                                                                                                    farInp,
                                                                                                                    farExp
                                                                                                                  #)
                                                                                                         in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp
                                                            )
                                                            inp
                                                            Data.Map.Internal.Tip
                                                  )
                                                  failInp
                                                  Data.Map.Internal.Tip
                                        else
                                          let _ = "choicesBranch.else"
                                           in finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp
                                    loop = \_callReturn callInput callCatchStackByLabel ->
                                      let _ = "catch ExceptionFailure"
                                       in let catchHandler (!_exn) (!failInp) (!farInp) (!farExp) =
                                                let _ = "catch.ko ExceptionFailure"
                                                 in catchHandler callInput Symantic.Parser.Grammar.Combinators.ExceptionFailure callInput farInp farExp
                                           in let readFail = catchHandler
                                               in if readMore (Symantic.Parser.Machine.Input.shiftRightText 12 callInput)
                                                    then
                                                      let !(#
                                                             c,
                                                             cs
                                                             #) = readNext callInput
                                                       in if (GHC.Classes.==) 'f' c
                                                            then
                                                              let readFail = readFail
                                                               in let !(#
                                                                         c,
                                                                         cs
                                                                         #) = readNext cs
                                                                   in if (GHC.Classes.==) 'u' c
                                                                        then
                                                                          let readFail = readFail
                                                                           in let !(#
                                                                                     c,
                                                                                     cs
                                                                                     #) = readNext cs
                                                                               in if (GHC.Classes.==) 'n' c
                                                                                    then
                                                                                      let readFail = readFail
                                                                                       in let !(#
                                                                                                 c,
                                                                                                 cs
                                                                                                 #) = readNext cs
                                                                                           in if (GHC.Classes.==) 'c' c
                                                                                                then
                                                                                                  let readFail = readFail
                                                                                                   in let !(#
                                                                                                             c,
                                                                                                             cs
                                                                                                             #) = readNext cs
                                                                                                       in if (GHC.Classes.==) 't' c
                                                                                                            then
                                                                                                              let readFail = readFail
                                                                                                               in let !(#
                                                                                                                         c,
                                                                                                                         cs
                                                                                                                         #) = readNext cs
                                                                                                                   in if (GHC.Classes.==) 'i' c
                                                                                                                        then
                                                                                                                          let readFail = readFail
                                                                                                                           in let !(#
                                                                                                                                     c,
                                                                                                                                     cs
                                                                                                                                     #) = readNext cs
                                                                                                                               in if (GHC.Classes.==) 'o' c
                                                                                                                                    then
                                                                                                                                      let readFail = readFail
                                                                                                                                       in let !(#
                                                                                                                                                 c,
                                                                                                                                                 cs
                                                                                                                                                 #) = readNext cs
                                                                                                                                           in if (GHC.Classes.==) 'n' c
                                                                                                                                                then
                                                                                                                                                  name
                                                                                                                                                    ( let _ = "suspend"
                                                                                                                                                       in \farInp farExp v (!inp) ->
                                                                                                                                                            name
                                                                                                                                                              ( let _ = "suspend"
                                                                                                                                                                 in \farInp farExp v (!inp) ->
                                                                                                                                                                      name
                                                                                                                                                                        ( let _ = "suspend"
                                                                                                                                                                           in \farInp farExp v (!inp) ->
                                                                                                                                                                                name
                                                                                                                                                                                  ( let _ = "suspend"
                                                                                                                                                                                     in \farInp farExp v (!inp) ->
                                                                                                                                                                                          let join = \farInp farExp v (!inp) ->
                                                                                                                                                                                                name
                                                                                                                                                                                                  ( let _ = "suspend"
                                                                                                                                                                                                     in \farInp farExp v (!inp) ->
                                                                                                                                                                                                          name
                                                                                                                                                                                                            ( let _ = "suspend"
                                                                                                                                                                                                               in \farInp farExp v (!inp) -> do
                                                                                                                                                                                                                    sr <- GHC.STRef.readSTRef reg
                                                                                                                                                                                                                    do
                                                                                                                                                                                                                      let dupv = sr
                                                                                                                                                                                                                      GHC.STRef.writeSTRef reg dupv
                                                                                                                                                                                                                      let _ = "jump"
                                                                                                                                                                                                                       in loop (GHC.Err.error "invalid return") inp (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure (catchHandler callInput) Data.Map.Internal.Tip Data.Map.Internal.Tip)
                                                                                                                                                                                                            )
                                                                                                                                                                                                            inp
                                                                                                                                                                                                            (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure (catchHandler callInput) Data.Map.Internal.Tip Data.Map.Internal.Tip)
                                                                                                                                                                                                  )
                                                                                                                                                                                                  inp
                                                                                                                                                                                                  (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure (catchHandler callInput) Data.Map.Internal.Tip Data.Map.Internal.Tip)
                                                                                                                                                                                           in let _ = "catch ExceptionFailure"
                                                                                                                                                                                               in let catchHandler (!_exn) (!failInp) (!farInp) (!farExp) =
                                                                                                                                                                                                        let _ = "catch.ko ExceptionFailure"
                                                                                                                                                                                                         in if ( \( Data.Text.Internal.Text
                                                                                                                                                                                                                      _
                                                                                                                                                                                                                      i
                                                                                                                                                                                                                      _
                                                                                                                                                                                                                    )
                                                                                                                                                                                                                  ( Data.Text.Internal.Text
                                                                                                                                                                                                                      _
                                                                                                                                                                                                                      j
                                                                                                                                                                                                                      _
                                                                                                                                                                                                                    ) -> i GHC.Classes.== j
                                                                                                                                                                                                               )
                                                                                                                                                                                                              inp
                                                                                                                                                                                                              failInp
                                                                                                                                                                                                              then
                                                                                                                                                                                                                let _ = "choicesBranch.then"
                                                                                                                                                                                                                 in name
                                                                                                                                                                                                                      ( let _ = "suspend"
                                                                                                                                                                                                                         in \farInp farExp v (!inp) ->
                                                                                                                                                                                                                              let _ = "resume"
                                                                                                                                                                                                                               in join
                                                                                                                                                                                                                                    farInp
                                                                                                                                                                                                                                    farExp
                                                                                                                                                                                                                                    ( let _ = "resume.genCode"
                                                                                                                                                                                                                                       in v
                                                                                                                                                                                                                                    )
                                                                                                                                                                                                                                    inp
                                                                                                                                                                                                                      )
                                                                                                                                                                                                                      failInp
                                                                                                                                                                                                                      Data.Map.Internal.Tip
                                                                                                                                                                                                              else
                                                                                                                                                                                                                let _ = "choicesBranch.else"
                                                                                                                                                                                                                 in catchHandler callInput Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp
                                                                                                                                                                                                   in let readFail = catchHandler
                                                                                                                                                                                                       in if readMore inp
                                                                                                                                                                                                            then
                                                                                                                                                                                                              let !(#
                                                                                                                                                                                                                     c,
                                                                                                                                                                                                                     cs
                                                                                                                                                                                                                     #) = readNext inp
                                                                                                                                                                                                               in if (GHC.Classes.==) ':' c
                                                                                                                                                                                                                    then
                                                                                                                                                                                                                      name
                                                                                                                                                                                                                        ( let _ = "suspend"
                                                                                                                                                                                                                           in \farInp farExp v (!inp) ->
                                                                                                                                                                                                                                name
                                                                                                                                                                                                                                  ( let _ = "suspend"
                                                                                                                                                                                                                                     in \farInp farExp v (!inp) ->
                                                                                                                                                                                                                                          let _ = "resume"
                                                                                                                                                                                                                                           in join
                                                                                                                                                                                                                                                farInp
                                                                                                                                                                                                                                                farExp
                                                                                                                                                                                                                                                ( let _ = "resume.genCode"
                                                                                                                                                                                                                                                   in GHC.Tuple . ()
                                                                                                                                                                                                                                                )
                                                                                                                                                                                                                                                inp
                                                                                                                                                                                                                                  )
                                                                                                                                                                                                                                  inp
                                                                                                                                                                                                                                  (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure readFail Data.Map.Internal.Tip Data.Map.Internal.Tip)
                                                                                                                                                                                                                        )
                                                                                                                                                                                                                        cs
                                                                                                                                                                                                                        (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure readFail Data.Map.Internal.Tip Data.Map.Internal.Tip)
                                                                                                                                                                                                                    else
                                                                                                                                                                                                                      let _ = "checkToken.else"
                                                                                                                                                                                                                       in let failExp =
                                                                                                                                                                                                                                Data.Set.Internal.Bin
                                                                                                                                                                                                                                  1
                                                                                                                                                                                                                                  ( Symantic.Parser.Grammar.Combinators.SomeFailure
                                                                                                                                                                                                                                      ( case inputToken of
                                                                                                                                                                                                                                          (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken ':'
                                                                                                                                                                                                                                      )
                                                                                                                                                                                                                                  )
                                                                                                                                                                                                                                  Data.Set.Internal.Tip
                                                                                                                                                                                                                                  Data.Set.Internal.Tip
                                                                                                                                                                                                                           in let (#
                                                                                                                                                                                                                                    farInp,
                                                                                                                                                                                                                                    farExp
                                                                                                                                                                                                                                    #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp inp of
                                                                                                                                                                                                                                      GHC.Types.LT ->
                                                                                                                                                                                                                                        (#
                                                                                                                                                                                                                                          inp,
                                                                                                                                                                                                                                          failExp
                                                                                                                                                                                                                                        #)
                                                                                                                                                                                                                                      GHC.Types.EQ ->
                                                                                                                                                                                                                                        (#
                                                                                                                                                                                                                                          farInp,
                                                                                                                                                                                                                                          failExp GHC.Base.<> farExp
                                                                                                                                                                                                                                        #)
                                                                                                                                                                                                                                      GHC.Types.GT ->
                                                                                                                                                                                                                                        (#
                                                                                                                                                                                                                                          farInp,
                                                                                                                                                                                                                                          farExp
                                                                                                                                                                                                                                        #)
                                                                                                                                                                                                                               in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp
                                                                                                                                                                                                            else
                                                                                                                                                                                                              let _ = "checkHorizon.else"
                                                                                                                                                                                                               in let failExp =
                                                                                                                                                                                                                        Data.Set.Internal.Bin
                                                                                                                                                                                                                          1
                                                                                                                                                                                                                          ( Symantic.Parser.Grammar.Combinators.SomeFailure
                                                                                                                                                                                                                              ( case inputToken of
                                                                                                                                                                                                                                  (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 1
                                                                                                                                                                                                                              )
                                                                                                                                                                                                                          )
                                                                                                                                                                                                                          Data.Set.Internal.Tip
                                                                                                                                                                                                                          Data.Set.Internal.Tip
                                                                                                                                                                                                                   in let (#
                                                                                                                                                                                                                            farInp,
                                                                                                                                                                                                                            farExp
                                                                                                                                                                                                                            #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp inp of
                                                                                                                                                                                                                              GHC.Types.LT ->
                                                                                                                                                                                                                                (#
                                                                                                                                                                                                                                  inp,
                                                                                                                                                                                                                                  failExp
                                                                                                                                                                                                                                #)
                                                                                                                                                                                                                              GHC.Types.EQ ->
                                                                                                                                                                                                                                (#
                                                                                                                                                                                                                                  farInp,
                                                                                                                                                                                                                                  failExp GHC.Base.<> farExp
                                                                                                                                                                                                                                #)
                                                                                                                                                                                                                              GHC.Types.GT ->
                                                                                                                                                                                                                                (#
                                                                                                                                                                                                                                  farInp,
                                                                                                                                                                                                                                  farExp
                                                                                                                                                                                                                                #)
                                                                                                                                                                                                                       in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp
                                                                                                                                                                                  )
                                                                                                                                                                                  inp
                                                                                                                                                                                  (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure (catchHandler callInput) Data.Map.Internal.Tip Data.Map.Internal.Tip)
                                                                                                                                                                        )
                                                                                                                                                                        inp
                                                                                                                                                                        (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure (catchHandler callInput) Data.Map.Internal.Tip Data.Map.Internal.Tip)
                                                                                                                                                              )
                                                                                                                                                              inp
                                                                                                                                                              (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure (catchHandler callInput) Data.Map.Internal.Tip Data.Map.Internal.Tip)
                                                                                                                                                    )
                                                                                                                                                    cs
                                                                                                                                                    Data.Map.Internal.Tip
                                                                                                                                                else
                                                                                                                                                  let _ = "checkToken.else"
                                                                                                                                                   in let failExp =
                                                                                                                                                            Data.Set.Internal.Bin
                                                                                                                                                              1
                                                                                                                                                              ( Symantic.Parser.Grammar.Combinators.SomeFailure
                                                                                                                                                                  ( case inputToken of
                                                                                                                                                                      (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'n'
                                                                                                                                                                  )
                                                                                                                                                              )
                                                                                                                                                              Data.Set.Internal.Tip
                                                                                                                                                              Data.Set.Internal.Tip
                                                                                                                                                       in let (#
                                                                                                                                                                farInp,
                                                                                                                                                                farExp
                                                                                                                                                                #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp cs of
                                                                                                                                                                  GHC.Types.LT ->
                                                                                                                                                                    (#
                                                                                                                                                                      cs,
                                                                                                                                                                      failExp
                                                                                                                                                                    #)
                                                                                                                                                                  GHC.Types.EQ ->
                                                                                                                                                                    (#
                                                                                                                                                                      farInp,
                                                                                                                                                                      failExp GHC.Base.<> farExp
                                                                                                                                                                    #)
                                                                                                                                                                  GHC.Types.GT ->
                                                                                                                                                                    (#
                                                                                                                                                                      farInp,
                                                                                                                                                                      farExp
                                                                                                                                                                    #)
                                                                                                                                                           in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure cs farInp farExp
                                                                                                                                    else
                                                                                                                                      let _ = "checkToken.else"
                                                                                                                                       in let failExp =
                                                                                                                                                Data.Set.Internal.Bin
                                                                                                                                                  1
                                                                                                                                                  ( Symantic.Parser.Grammar.Combinators.SomeFailure
                                                                                                                                                      ( case inputToken of
                                                                                                                                                          (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'o'
                                                                                                                                                      )
                                                                                                                                                  )
                                                                                                                                                  Data.Set.Internal.Tip
                                                                                                                                                  Data.Set.Internal.Tip
                                                                                                                                           in let (#
                                                                                                                                                    farInp,
                                                                                                                                                    farExp
                                                                                                                                                    #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp cs of
                                                                                                                                                      GHC.Types.LT ->
                                                                                                                                                        (#
                                                                                                                                                          cs,
                                                                                                                                                          failExp
                                                                                                                                                        #)
                                                                                                                                                      GHC.Types.EQ ->
                                                                                                                                                        (#
                                                                                                                                                          farInp,
                                                                                                                                                          failExp GHC.Base.<> farExp
                                                                                                                                                        #)
                                                                                                                                                      GHC.Types.GT ->
                                                                                                                                                        (#
                                                                                                                                                          farInp,
                                                                                                                                                          farExp
                                                                                                                                                        #)
                                                                                                                                               in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure cs farInp farExp
                                                                                                                        else
                                                                                                                          let _ = "checkToken.else"
                                                                                                                           in let failExp =
                                                                                                                                    Data.Set.Internal.Bin
                                                                                                                                      1
                                                                                                                                      ( Symantic.Parser.Grammar.Combinators.SomeFailure
                                                                                                                                          ( case inputToken of
                                                                                                                                              (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'i'
                                                                                                                                          )
                                                                                                                                      )
                                                                                                                                      Data.Set.Internal.Tip
                                                                                                                                      Data.Set.Internal.Tip
                                                                                                                               in let (#
                                                                                                                                        farInp,
                                                                                                                                        farExp
                                                                                                                                        #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp cs of
                                                                                                                                          GHC.Types.LT ->
                                                                                                                                            (#
                                                                                                                                              cs,
                                                                                                                                              failExp
                                                                                                                                            #)
                                                                                                                                          GHC.Types.EQ ->
                                                                                                                                            (#
                                                                                                                                              farInp,
                                                                                                                                              failExp GHC.Base.<> farExp
                                                                                                                                            #)
                                                                                                                                          GHC.Types.GT ->
                                                                                                                                            (#
                                                                                                                                              farInp,
                                                                                                                                              farExp
                                                                                                                                            #)
                                                                                                                                   in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure cs farInp farExp
                                                                                                            else
                                                                                                              let _ = "checkToken.else"
                                                                                                               in let failExp =
                                                                                                                        Data.Set.Internal.Bin
                                                                                                                          1
                                                                                                                          ( Symantic.Parser.Grammar.Combinators.SomeFailure
                                                                                                                              ( case inputToken of
                                                                                                                                  (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 't'
                                                                                                                              )
                                                                                                                          )
                                                                                                                          Data.Set.Internal.Tip
                                                                                                                          Data.Set.Internal.Tip
                                                                                                                   in let (#
                                                                                                                            farInp,
                                                                                                                            farExp
                                                                                                                            #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp cs of
                                                                                                                              GHC.Types.LT ->
                                                                                                                                (#
                                                                                                                                  cs,
                                                                                                                                  failExp
                                                                                                                                #)
                                                                                                                              GHC.Types.EQ ->
                                                                                                                                (#
                                                                                                                                  farInp,
                                                                                                                                  failExp GHC.Base.<> farExp
                                                                                                                                #)
                                                                                                                              GHC.Types.GT ->
                                                                                                                                (#
                                                                                                                                  farInp,
                                                                                                                                  farExp
                                                                                                                                #)
                                                                                                                       in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure cs farInp farExp
                                                                                                else
                                                                                                  let _ = "checkToken.else"
                                                                                                   in let failExp =
                                                                                                            Data.Set.Internal.Bin
                                                                                                              1
                                                                                                              ( Symantic.Parser.Grammar.Combinators.SomeFailure
                                                                                                                  ( case inputToken of
                                                                                                                      (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'c'
                                                                                                                  )
                                                                                                              )
                                                                                                              Data.Set.Internal.Tip
                                                                                                              Data.Set.Internal.Tip
                                                                                                       in let (#
                                                                                                                farInp,
                                                                                                                farExp
                                                                                                                #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp cs of
                                                                                                                  GHC.Types.LT ->
                                                                                                                    (#
                                                                                                                      cs,
                                                                                                                      failExp
                                                                                                                    #)
                                                                                                                  GHC.Types.EQ ->
                                                                                                                    (#
                                                                                                                      farInp,
                                                                                                                      failExp GHC.Base.<> farExp
                                                                                                                    #)
                                                                                                                  GHC.Types.GT ->
                                                                                                                    (#
                                                                                                                      farInp,
                                                                                                                      farExp
                                                                                                                    #)
                                                                                                           in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure cs farInp farExp
                                                                                    else
                                                                                      let _ = "checkToken.else"
                                                                                       in let failExp =
                                                                                                Data.Set.Internal.Bin
                                                                                                  1
                                                                                                  ( Symantic.Parser.Grammar.Combinators.SomeFailure
                                                                                                      ( case inputToken of
                                                                                                          (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'n'
                                                                                                      )
                                                                                                  )
                                                                                                  Data.Set.Internal.Tip
                                                                                                  Data.Set.Internal.Tip
                                                                                           in let (#
                                                                                                    farInp,
                                                                                                    farExp
                                                                                                    #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp cs of
                                                                                                      GHC.Types.LT ->
                                                                                                        (#
                                                                                                          cs,
                                                                                                          failExp
                                                                                                        #)
                                                                                                      GHC.Types.EQ ->
                                                                                                        (#
                                                                                                          farInp,
                                                                                                          failExp GHC.Base.<> farExp
                                                                                                        #)
                                                                                                      GHC.Types.GT ->
                                                                                                        (#
                                                                                                          farInp,
                                                                                                          farExp
                                                                                                        #)
                                                                                               in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure cs farInp farExp
                                                                        else
                                                                          let _ = "checkToken.else"
                                                                           in let failExp =
                                                                                    Data.Set.Internal.Bin
                                                                                      1
                                                                                      ( Symantic.Parser.Grammar.Combinators.SomeFailure
                                                                                          ( case inputToken of
                                                                                              (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'u'
                                                                                          )
                                                                                      )
                                                                                      Data.Set.Internal.Tip
                                                                                      Data.Set.Internal.Tip
                                                                               in let (#
                                                                                        farInp,
                                                                                        farExp
                                                                                        #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp cs of
                                                                                          GHC.Types.LT ->
                                                                                            (#
                                                                                              cs,
                                                                                              failExp
                                                                                            #)
                                                                                          GHC.Types.EQ ->
                                                                                            (#
                                                                                              farInp,
                                                                                              failExp GHC.Base.<> farExp
                                                                                            #)
                                                                                          GHC.Types.GT ->
                                                                                            (#
                                                                                              farInp,
                                                                                              farExp
                                                                                            #)
                                                                                   in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure cs farInp farExp
                                                            else
                                                              let _ = "checkToken.else"
                                                               in let failExp =
                                                                        Data.Set.Internal.Bin
                                                                          1
                                                                          ( Symantic.Parser.Grammar.Combinators.SomeFailure
                                                                              ( case inputToken of
                                                                                  (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'f'
                                                                              )
                                                                          )
                                                                          Data.Set.Internal.Tip
                                                                          Data.Set.Internal.Tip
                                                                   in let (#
                                                                            farInp,
                                                                            farExp
                                                                            #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp callInput of
                                                                              GHC.Types.LT ->
                                                                                (#
                                                                                  callInput,
                                                                                  failExp
                                                                                #)
                                                                              GHC.Types.EQ ->
                                                                                (#
                                                                                  farInp,
                                                                                  failExp GHC.Base.<> farExp
                                                                                #)
                                                                              GHC.Types.GT ->
                                                                                (#
                                                                                  farInp,
                                                                                  farExp
                                                                                #)
                                                                       in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure callInput farInp farExp
                                                    else
                                                      let _ = "checkHorizon.else"
                                                       in let failExp =
                                                                Data.Set.Internal.Bin
                                                                  1
                                                                  ( Symantic.Parser.Grammar.Combinators.SomeFailure
                                                                      ( case inputToken of
                                                                          (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 13
                                                                      )
                                                                  )
                                                                  Data.Set.Internal.Tip
                                                                  Data.Set.Internal.Tip
                                                           in let (#
                                                                    farInp,
                                                                    farExp
                                                                    #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp callInput of
                                                                      GHC.Types.LT ->
                                                                        (#
                                                                          callInput,
                                                                          failExp
                                                                        #)
                                                                      GHC.Types.EQ ->
                                                                        (#
                                                                          farInp,
                                                                          failExp GHC.Base.<> farExp
                                                                        #)
                                                                      GHC.Types.GT ->
                                                                        (#
                                                                          farInp,
                                                                          farExp
                                                                        #)
                                                               in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure callInput farInp farExp
                                 in let _ = "jump"
                                     in loop finalRet inp Data.Map.Internal.Tip
                    )
                    init
                    Data.Map.Internal.Tip
        )