\(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 -> Data.Either.Right v
      finalRaise ::
        forall b.
        Symantic.Parser.Machine.Generate.Catcher
          inp
          b = \(!exn) _failInp (!farInp) (!farExp) ->
          Data.Either.Left
            Symantic.Parser.Machine.Generate.ParsingErrorStandard
              { 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 let inputToken = Data.Proxy.Proxy :: Data.Proxy.Proxy (Symantic.Parser.Machine.Input.InputToken inp)
       in let name = \(!ok) (!inp) (!koByLabel) ->
                name
                  ( let _ = "suspend"
                     in \farInp farExp v (!inp) ->
                          let _ = "resume"
                           in ok
                                farInp
                                farExp
                                ( let _ = "resume.genCode"
                                   in GHC.Tuple . ()
                                )
                                inp
                  )
                  inp
                  (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure (Data.Map.Strict.Internal.findWithDefault finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure koByLabel) Data.Map.Internal.Tip Data.Map.Internal.Tip)
              name = \(!ok) (!inp) (!koByLabel) ->
                name
                  ( let _ = "suspend"
                     in \farInp farExp v (!inp) ->
                          let _ = "resume"
                           in ok
                                farInp
                                farExp
                                ( let _ = "resume.genCode"
                                   in v GHC.Types . []
                                )
                                inp
                  )
                  inp
                  (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure (Data.Map.Strict.Internal.findWithDefault finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure koByLabel) Data.Map.Internal.Tip Data.Map.Internal.Tip)
              name = \(!ok) (!inp) (!koByLabel) ->
                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 _ = "resume"
                                       in ok
                                            farInp
                                            farExp
                                            ( let _ = "resume.genCode"
                                               in \x -> x
                                            )
                                            failInp
                                else
                                  let _ = "choicesBranch.else"
                                   in Data.Map.Strict.Internal.findWithDefault finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure koByLabel Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp
                     in let join = \farInp farExp v (!inp) ->
                              name
                                ( let _ = "suspend"
                                   in \farInp farExp v (!inp) ->
                                        name
                                          ( let _ = "suspend"
                                             in \farInp farExp v (!inp) ->
                                                  let _ = "resume"
                                                   in ok
                                                        farInp
                                                        farExp
                                                        ( let _ = "resume.genCode"
                                                           in \x -> (GHC.Types.:) v (v x)
                                                        )
                                                        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)
                         in let readFail = catchHandler
                             in if readMore inp
                                  then
                                    let !(#
                                           c,
                                           cs
                                           #) = readNext inp
                                     in if (\x -> \x -> x) GHC.Types.True c
                                          then
                                            if (GHC.Classes.==) '<' c
                                              then
                                                let _ = "choicesBranch.then"
                                                 in let readFail = readFail
                                                     in if readMore inp
                                                          then
                                                            let !(#
                                                                   c,
                                                                   cs
                                                                   #) = readNext inp
                                                             in if (\x -> \x -> x) GHC.Types.True c
                                                                  then
                                                                    let _ = "resume"
                                                                     in join
                                                                          init
                                                                          Data.Set.Internal.empty
                                                                          ( let _ = "resume.genCode"
                                                                             in Parsers.Brainfuck.Types.Backward
                                                                          )
                                                                          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.FailureAny @tok'
                                                                                    )
                                                                                )
                                                                                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 inp of
                                                                                    GHC.Types.LT ->
                                                                                      (#
                                                                                        inp,
                                                                                        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 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) init inp of
                                                                            GHC.Types.LT ->
                                                                              (#
                                                                                inp,
                                                                                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 inp farInp farExp
                                              else
                                                let _ = "choicesBranch.else"
                                                 in if (GHC.Classes.==) '>' c
                                                      then
                                                        let _ = "choicesBranch.then"
                                                         in let readFail = readFail
                                                             in if readMore inp
                                                                  then
                                                                    let !(#
                                                                           c,
                                                                           cs
                                                                           #) = readNext inp
                                                                     in if (\x -> \x -> x) GHC.Types.True c
                                                                          then
                                                                            let _ = "resume"
                                                                             in join
                                                                                  init
                                                                                  Data.Set.Internal.empty
                                                                                  ( let _ = "resume.genCode"
                                                                                     in Parsers.Brainfuck.Types.Forward
                                                                                  )
                                                                                  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.FailureAny @tok'
                                                                                            )
                                                                                        )
                                                                                        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 inp of
                                                                                            GHC.Types.LT ->
                                                                                              (#
                                                                                                inp,
                                                                                                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 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) init inp of
                                                                                    GHC.Types.LT ->
                                                                                      (#
                                                                                        inp,
                                                                                        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 inp farInp farExp
                                                      else
                                                        let _ = "choicesBranch.else"
                                                         in if (GHC.Classes.==) '+' c
                                                              then
                                                                let _ = "choicesBranch.then"
                                                                 in let readFail = readFail
                                                                     in if readMore inp
                                                                          then
                                                                            let !(#
                                                                                   c,
                                                                                   cs
                                                                                   #) = readNext inp
                                                                             in if (\x -> \x -> x) GHC.Types.True c
                                                                                  then
                                                                                    let _ = "resume"
                                                                                     in join
                                                                                          init
                                                                                          Data.Set.Internal.empty
                                                                                          ( let _ = "resume.genCode"
                                                                                             in Parsers.Brainfuck.Types.Increment
                                                                                          )
                                                                                          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.FailureAny @tok'
                                                                                                    )
                                                                                                )
                                                                                                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 inp of
                                                                                                    GHC.Types.LT ->
                                                                                                      (#
                                                                                                        inp,
                                                                                                        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 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) init inp of
                                                                                            GHC.Types.LT ->
                                                                                              (#
                                                                                                inp,
                                                                                                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 inp farInp farExp
                                                              else
                                                                let _ = "choicesBranch.else"
                                                                 in if (GHC.Classes.==) '-' c
                                                                      then
                                                                        let _ = "choicesBranch.then"
                                                                         in let readFail = readFail
                                                                             in if readMore inp
                                                                                  then
                                                                                    let !(#
                                                                                           c,
                                                                                           cs
                                                                                           #) = readNext inp
                                                                                     in if (\x -> \x -> x) GHC.Types.True c
                                                                                          then
                                                                                            let _ = "resume"
                                                                                             in join
                                                                                                  init
                                                                                                  Data.Set.Internal.empty
                                                                                                  ( let _ = "resume.genCode"
                                                                                                     in Parsers.Brainfuck.Types.Decrement
                                                                                                  )
                                                                                                  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.FailureAny @tok'
                                                                                                            )
                                                                                                        )
                                                                                                        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 inp of
                                                                                                            GHC.Types.LT ->
                                                                                                              (#
                                                                                                                inp,
                                                                                                                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 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) init inp of
                                                                                                    GHC.Types.LT ->
                                                                                                      (#
                                                                                                        inp,
                                                                                                        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 inp farInp farExp
                                                                      else
                                                                        let _ = "choicesBranch.else"
                                                                         in if (GHC.Classes.==) ',' c
                                                                              then
                                                                                let _ = "choicesBranch.then"
                                                                                 in let readFail = readFail
                                                                                     in if readMore inp
                                                                                          then
                                                                                            let !(#
                                                                                                   c,
                                                                                                   cs
                                                                                                   #) = readNext inp
                                                                                             in if (\x -> \x -> x) GHC.Types.True c
                                                                                                  then
                                                                                                    let _ = "resume"
                                                                                                     in join
                                                                                                          init
                                                                                                          Data.Set.Internal.empty
                                                                                                          ( let _ = "resume.genCode"
                                                                                                             in Parsers.Brainfuck.Types.Input
                                                                                                          )
                                                                                                          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.FailureAny @tok'
                                                                                                                    )
                                                                                                                )
                                                                                                                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 inp of
                                                                                                                    GHC.Types.LT ->
                                                                                                                      (#
                                                                                                                        inp,
                                                                                                                        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 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) init inp of
                                                                                                            GHC.Types.LT ->
                                                                                                              (#
                                                                                                                inp,
                                                                                                                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 inp farInp farExp
                                                                              else
                                                                                let _ = "choicesBranch.else"
                                                                                 in if (GHC.Classes.==) '.' c
                                                                                      then
                                                                                        let _ = "choicesBranch.then"
                                                                                         in let readFail = readFail
                                                                                             in if readMore inp
                                                                                                  then
                                                                                                    let !(#
                                                                                                           c,
                                                                                                           cs
                                                                                                           #) = readNext inp
                                                                                                     in if (\x -> \x -> x) GHC.Types.True c
                                                                                                          then
                                                                                                            let _ = "resume"
                                                                                                             in join
                                                                                                                  init
                                                                                                                  Data.Set.Internal.empty
                                                                                                                  ( let _ = "resume.genCode"
                                                                                                                     in Parsers.Brainfuck.Types.Output
                                                                                                                  )
                                                                                                                  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.FailureAny @tok'
                                                                                                                            )
                                                                                                                        )
                                                                                                                        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 inp of
                                                                                                                            GHC.Types.LT ->
                                                                                                                              (#
                                                                                                                                inp,
                                                                                                                                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 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) init inp of
                                                                                                                    GHC.Types.LT ->
                                                                                                                      (#
                                                                                                                        inp,
                                                                                                                        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 inp farInp farExp
                                                                                      else
                                                                                        let _ = "choicesBranch.else"
                                                                                         in if (GHC.Classes.==) '[' c
                                                                                              then
                                                                                                let _ = "choicesBranch.then"
                                                                                                 in let readFail = readFail
                                                                                                     in if readMore (Symantic.Parser.Machine.Input.shiftRightText 1 inp)
                                                                                                          then
                                                                                                            let !(#
                                                                                                                   c,
                                                                                                                   cs
                                                                                                                   #) = readNext inp
                                                                                                             in if (\x -> \x -> x) GHC.Types.True c
                                                                                                                  then
                                                                                                                    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
                                                                                                                                                        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' 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 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.FailureAny @tok'
                                                                                                                                    )
                                                                                                                                )
                                                                                                                                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 inp of
                                                                                                                                    GHC.Types.LT ->
                                                                                                                                      (#
                                                                                                                                        inp,
                                                                                                                                        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 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) init inp of
                                                                                                                            GHC.Types.LT ->
                                                                                                                              (#
                                                                                                                                inp,
                                                                                                                                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 inp 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 inp of
                                                                                                                GHC.Types.LT ->
                                                                                                                  (#
                                                                                                                    inp,
                                                                                                                    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 inp 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.FailureAny @tok'
                                                            )
                                                        )
                                                        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 inp of
                                                            GHC.Types.LT ->
                                                              (#
                                                                inp,
                                                                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 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) init inp of
                                                    GHC.Types.LT ->
                                                      (#
                                                        inp,
                                                        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 inp farInp farExp
              name = \(!ok) (!inp) (!koByLabel) ->
                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 _ = "resume"
                                       in ok
                                            farInp
                                            farExp
                                            ( let _ = "resume.genCode"
                                               in \x -> x
                                            )
                                            failInp
                                else
                                  let _ = "choicesBranch.else"
                                   in Data.Map.Strict.Internal.findWithDefault finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure koByLabel Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp
                     in let readFail = catchHandler
                         in if readMore inp
                              then
                                let !(#
                                       c,
                                       cs
                                       #) = readNext inp
                                 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
                                        name
                                          ( let _ = "suspend"
                                             in \farInp farExp v (!inp) ->
                                                  let _ = "resume"
                                                   in ok
                                                        farInp
                                                        farExp
                                                        ( let _ = "resume.genCode"
                                                           in \x -> v x
                                                        )
                                                        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 readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp 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 inp of
                                                GHC.Types.LT ->
                                                  (#
                                                    inp,
                                                    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 inp farInp farExp
           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