\(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) -> 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 ->
                              let readFail = catchHandler callInput
                               in if readMore (Symantic.Parser.Machine.Input.shiftRightText 2 callInput)
                                    then
                                      let !(#
                                             c,
                                             cs
                                             #) = readNext callInput
                                       in if (\c -> GHC.Classes.not (('<' GHC.Classes.== c) GHC.Classes.|| (('>' GHC.Classes.== c) GHC.Classes.|| (('+' GHC.Classes.== c) GHC.Classes.|| (('-' GHC.Classes.== c) GHC.Classes.|| ((',' GHC.Classes.== c) GHC.Classes.|| (('.' GHC.Classes.== c) GHC.Classes.|| (('[' GHC.Classes.== c) GHC.Classes.|| ((']' GHC.Classes.== c) GHC.Classes.|| GHC.Types.False))))))))) 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 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) -> 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 sr GHC.Types . []
                                              )
                                              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 ->
                              let join = \farInp farExp v (!inp) ->
                                    name
                                      ( let _ = "suspend"
                                         in \farInp farExp v (!inp) -> do
                                              sr <- GHC.STRef.readSTRef reg
                                              do
                                                let dupv = \x -> sr ((GHC.Types.:) v x)
                                                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)
                               in let readFail = catchHandler callInput
                                   in if readMore callInput
                                        then
                                          let !(#
                                                 c,
                                                 cs
                                                 #) = readNext callInput
                                           in if (\x -> (\x -> \x -> (GHC.Classes.==) x x) '<' x) c
                                                then
                                                  let _ = "choicesBranch.then"
                                                   in let readFail = readFail
                                                       in if readMore (Symantic.Parser.Machine.Input.shiftRightText 1 callInput)
                                                            then
                                                              let !(#
                                                                     c,
                                                                     cs
                                                                     #) = readNext callInput
                                                               in let _ = "resume"
                                                                   in join
                                                                        init
                                                                        Data.Set.Internal.empty
                                                                        ( let _ = "resume.genCode"
                                                                           in Parsers.Brainfuck.Types.Backward
                                                                        )
                                                                        cs
                                                            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
                                                else
                                                  let _ = "choicesBranch.else"
                                                   in if (\x -> (\x -> \x -> (GHC.Classes.==) x x) '>' x) c
                                                        then
                                                          let _ = "choicesBranch.then"
                                                           in let readFail = readFail
                                                               in if readMore (Symantic.Parser.Machine.Input.shiftRightText 1 callInput)
                                                                    then
                                                                      let !(#
                                                                             c,
                                                                             cs
                                                                             #) = readNext callInput
                                                                       in let _ = "resume"
                                                                           in join
                                                                                init
                                                                                Data.Set.Internal.empty
                                                                                ( let _ = "resume.genCode"
                                                                                   in Parsers.Brainfuck.Types.Forward
                                                                                )
                                                                                cs
                                                                    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
                                                        else
                                                          let _ = "choicesBranch.else"
                                                           in if (\x -> (\x -> \x -> (GHC.Classes.==) x x) '+' x) c
                                                                then
                                                                  let _ = "choicesBranch.then"
                                                                   in let readFail = readFail
                                                                       in if readMore (Symantic.Parser.Machine.Input.shiftRightText 1 callInput)
                                                                            then
                                                                              let !(#
                                                                                     c,
                                                                                     cs
                                                                                     #) = readNext callInput
                                                                               in let _ = "resume"
                                                                                   in join
                                                                                        init
                                                                                        Data.Set.Internal.empty
                                                                                        ( let _ = "resume.genCode"
                                                                                           in Parsers.Brainfuck.Types.Increment
                                                                                        )
                                                                                        cs
                                                                            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
                                                                else
                                                                  let _ = "choicesBranch.else"
                                                                   in if (\x -> (\x -> \x -> (GHC.Classes.==) x x) '-' x) c
                                                                        then
                                                                          let _ = "choicesBranch.then"
                                                                           in let readFail = readFail
                                                                               in if readMore (Symantic.Parser.Machine.Input.shiftRightText 1 callInput)
                                                                                    then
                                                                                      let !(#
                                                                                             c,
                                                                                             cs
                                                                                             #) = readNext callInput
                                                                                       in let _ = "resume"
                                                                                           in join
                                                                                                init
                                                                                                Data.Set.Internal.empty
                                                                                                ( let _ = "resume.genCode"
                                                                                                   in Parsers.Brainfuck.Types.Decrement
                                                                                                )
                                                                                                cs
                                                                                    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
                                                                        else
                                                                          let _ = "choicesBranch.else"
                                                                           in if (\x -> (\x -> \x -> (GHC.Classes.==) x x) ',' x) c
                                                                                then
                                                                                  let _ = "choicesBranch.then"
                                                                                   in let readFail = readFail
                                                                                       in if readMore (Symantic.Parser.Machine.Input.shiftRightText 1 callInput)
                                                                                            then
                                                                                              let !(#
                                                                                                     c,
                                                                                                     cs
                                                                                                     #) = readNext callInput
                                                                                               in let _ = "resume"
                                                                                                   in join
                                                                                                        init
                                                                                                        Data.Set.Internal.empty
                                                                                                        ( let _ = "resume.genCode"
                                                                                                           in Parsers.Brainfuck.Types.Input
                                                                                                        )
                                                                                                        cs
                                                                                            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
                                                                                else
                                                                                  let _ = "choicesBranch.else"
                                                                                   in if (\x -> (\x -> \x -> (GHC.Classes.==) x x) '.' x) c
                                                                                        then
                                                                                          let _ = "choicesBranch.then"
                                                                                           in let readFail = readFail
                                                                                               in if readMore (Symantic.Parser.Machine.Input.shiftRightText 1 callInput)
                                                                                                    then
                                                                                                      let !(#
                                                                                                             c,
                                                                                                             cs
                                                                                                             #) = readNext callInput
                                                                                                       in let _ = "resume"
                                                                                                           in join
                                                                                                                init
                                                                                                                Data.Set.Internal.empty
                                                                                                                ( let _ = "resume.genCode"
                                                                                                                   in Parsers.Brainfuck.Types.Output
                                                                                                                )
                                                                                                                cs
                                                                                                    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
                                                                                        else
                                                                                          let _ = "choicesBranch.else"
                                                                                           in if (\x -> (\x -> \x -> (GHC.Classes.==) x x) '[' x) c
                                                                                                then
                                                                                                  let _ = "choicesBranch.then"
                                                                                                   in let readFail = readFail
                                                                                                       in if readMore (Symantic.Parser.Machine.Input.shiftRightText 2 callInput)
                                                                                                            then
                                                                                                              let !(#
                                                                                                                     c,
                                                                                                                     cs
                                                                                                                     #) = readNext callInput
                                                                                                               in name
                                                                                                                    ( let _ = "suspend"
                                                                                                                       in \farInp farExp v (!inp) ->
                                                                                                                            name
                                                                                                                              ( let _ = "suspend"
                                                                                                                                 in \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
                                                                                                                                                      let _ = "resume"
                                                                                                                                                       in join
                                                                                                                                                            farInp
                                                                                                                                                            farExp
                                                                                                                                                            ( let _ = "resume.genCode"
                                                                                                                                                               in Parsers.Brainfuck.Types.Loop v
                                                                                                                                                            )
                                                                                                                                                            cs
                                                                                                                                                    else
                                                                                                                                                      let _ = "checkToken.else"
                                                                                                                                                       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
                                                                                                                              )
                                                                                                                              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 _ = "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
                                                                                                else
                                                                                                  let _ = "choicesBranch.else"
                                                                                                   in let failExp = Data.Set.Internal.Bin 1 (Symantic.Parser.Grammar.Combinators.SomeFailure Symantic.Parser.Grammar.Combinators.FailureEmpty) 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
                         in let _ = "jump"
                             in loop callReturn 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)
               in name
                    ( let _ = "suspend"
                       in \farInp farExp v (!inp) ->
                            name
                              ( let _ = "suspend"
                                 in \farInp farExp v (!inp) ->
                                      let _ = "resume"
                                       in finalRet
                                            farInp
                                            farExp
                                            ( let _ = "resume.genCode"
                                               in GHC.Show.show v
                                            )
                                            inp
                              )
                              inp
                              Data.Map.Internal.Tip
                    )
                    init
                    Data.Map.Internal.Tip
        )