test/Golden/Splice/G19.expected.txt

   1 \(input :: inp) ->
   2   let !(#
   3          init,
   4          readMore,
   5          readNext
   6          #) =
   7           let _ = "cursorOf"
   8            in let next
   9                     ( t@( Data.Text.Internal.Text
  10                             arr
  11                             off
  12                             unconsumed
  13                           )
  14                       ) =
  15                       let !( Data.Text.Unsafe.Iter
  16                                c
  17                                d
  18                              ) = Data.Text.Unsafe.iter t 0
  19                        in (#
  20                             c,
  21                             Data.Text.Internal.Text arr (off GHC.Num.+ d) (unconsumed GHC.Num.- d)
  22                           #)
  23                   more
  24                     ( Data.Text.Internal.Text
  25                         _
  26                         _
  27                         unconsumed
  28                       ) = unconsumed GHC.Classes.> 0
  29                in (# input, more, next #)
  30       finalRet = \_farInp _farExp v _inp -> Symantic.Parser.Machine.Generate.returnST GHC.Base.$ Data.Either.Right v
  31       finalRaise ::
  32         forall st b.
  33         Symantic.Parser.Machine.Generate.OnException
  34           st
  35           inp
  36           b = \(!exn) _failInp (!farInp) (!farExp) ->
  37           Symantic.Parser.Machine.Generate.returnST GHC.Base.$
  38             Data.Either.Left
  39               Symantic.Parser.Machine.Generate.ParsingError
  40                 { Symantic.Parser.Machine.Generate.parsingErrorOffset = Symantic.Parser.Machine.Input.offset farInp,
  41                   Symantic.Parser.Machine.Generate.parsingErrorException = exn,
  42                   Symantic.Parser.Machine.Generate.parsingErrorUnexpected =
  43                     if readMore farInp
  44                       then
  45                         GHC.Maybe.Just
  46                           ( let (#
  47                                   c,
  48                                   _
  49                                   #) = readNext farInp
  50                              in c
  51                           )
  52                       else GHC.Maybe.Nothing,
  53                   Symantic.Parser.Machine.Generate.parsingErrorExpecting =
  54                     let ( minHoriz,
  55                           res
  56                           ) =
  57                             Data.Set.Internal.foldr
  58                               ( \f
  59                                  ( minH,
  60                                    acc
  61                                    ) -> case Symantic.Parser.Grammar.Combinators.unSomeFailure f of
  62                                     GHC.Maybe.Just (Symantic.Parser.Grammar.Combinators.FailureHorizon h :: Symantic.Parser.Grammar.Combinators.Failure (Symantic.Parser.Grammar.Combinators.CombSatisfiable (Symantic.Parser.Machine.Input.InputToken inp)))
  63                                       | GHC.Maybe.Just old <- minH ->
  64                                         ( GHC.Maybe.Just (GHC.Classes.min old h),
  65                                           acc
  66                                         )
  67                                       | GHC.Base.otherwise ->
  68                                         ( GHC.Maybe.Just h,
  69                                           acc
  70                                         )
  71                                     _ ->
  72                                       ( minH,
  73                                         f GHC.Types.: acc
  74                                       )
  75                               )
  76                               ( GHC.Maybe.Nothing,
  77                                 GHC.Types . []
  78                               )
  79                               farExp
  80                      in Data.Set.Internal.fromList GHC.Base.$
  81                           ( case minHoriz of
  82                               GHC.Maybe.Just h -> Symantic.Parser.Grammar.Combinators.SomeFailure (Symantic.Parser.Grammar.Combinators.FailureHorizon @(Symantic.Parser.Machine.Input.InputToken inp) h) GHC.Types.: res
  83                               GHC.Maybe.Nothing -> res
  84                           )
  85                 }
  86    in GHC.ST.runST
  87         ( let inputToken = Data.Proxy.Proxy :: Data.Proxy.Proxy (Symantic.Parser.Machine.Input.InputToken inp)
  88            in let inp = init
  89                in let readFail = finalRaise
  90                    in let _ = "checkHorizon.newCheck: checkedHorizon=0 minHoriz=2"
  91                        in if readMore (Symantic.Parser.Machine.Input.shiftRightText 1 inp)
  92                             then
  93                               let
  94                                in let _ = "pushValue"
  95                                    in let join = \farInp farExp v (!inp) ->
  96                                             let _ = "lift2Value checkedHorizon=0"
  97                                              in let _ = "resume"
  98                                                  in finalRet
  99                                                       farInp
 100                                                       farExp
 101                                                       ( let _ = "resume.genCode"
 102                                                          in GHC.Show.show v
 103                                                       )
 104                                                       inp
 105                                        in let _ = "catch ExceptionFailure checkedHorizon=2"
 106                                            in let onException =
 107                                                     let _ = "onException"
 108                                                      in \(!_exn) (!failInp) (!farInp) (!farExp) ->
 109                                                           let _ = "comment: raiseAgainIfConsumed"
 110                                                            in let _ = "saveInput checkedHorizon=0"
 111                                                                in let _ = "lift2Value checkedHorizon=0"
 112                                                                    in if ( \( Data.Text.Internal.Text
 113                                                                                 _
 114                                                                                 i
 115                                                                                 _
 116                                                                               )
 117                                                                             ( Data.Text.Internal.Text
 118                                                                                 _
 119                                                                                 j
 120                                                                                 _
 121                                                                               ) -> i GHC.Classes.== j
 122                                                                          )
 123                                                                         inp
 124                                                                         failInp
 125                                                                         then
 126                                                                           let _ = "choicesBranch checkedHorizon=0"
 127                                                                            in let _ = "catch ExceptionFailure checkedHorizon=0"
 128                                                                                in let onException =
 129                                                                                         let _ = "onException"
 130                                                                                          in \(!_exn) (!failInp) (!farInp) (!farExp) ->
 131                                                                                               let _ = "comment: raiseAgainIfConsumed"
 132                                                                                                in let _ = "saveInput checkedHorizon=0"
 133                                                                                                    in let _ = "lift2Value checkedHorizon=0"
 134                                                                                                        in if ( \( Data.Text.Internal.Text
 135                                                                                                                     _
 136                                                                                                                     i
 137                                                                                                                     _
 138                                                                                                                   )
 139                                                                                                                 ( Data.Text.Internal.Text
 140                                                                                                                     _
 141                                                                                                                     j
 142                                                                                                                     _
 143                                                                                                                   ) -> i GHC.Classes.== j
 144                                                                                                              )
 145                                                                                                             failInp
 146                                                                                                             failInp
 147                                                                                                             then
 148                                                                                                               let _ = "choicesBranch checkedHorizon=0"
 149                                                                                                                in let _ = "catch ExceptionFailure checkedHorizon=0"
 150                                                                                                                    in let onException =
 151                                                                                                                             let _ = "onException"
 152                                                                                                                              in \(!_exn) (!failInp) (!farInp) (!farExp) ->
 153                                                                                                                                   let _ = "loadInput checkedHorizon=0"
 154                                                                                                                                    in let _ = "checkHorizon.noCheck"
 155                                                                                                                                        in finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp
 156                                                                                                                        in let _ = "pushValue"
 157                                                                                                                            in let _ = "comment: satisfy ((GHC.Classes.==) 'f')"
 158                                                                                                                                in let inp = failInp
 159                                                                                                                                    in let readFail = onException
 160                                                                                                                                        in let _ = "checkHorizon.newCheck: checkedHorizon=0 minHoriz=4"
 161                                                                                                                                            in if readMore (Symantic.Parser.Machine.Input.shiftRightText 3 inp)
 162                                                                                                                                                 then
 163                                                                                                                                                   let _ = "checkToken"
 164                                                                                                                                                    in let !(#
 165                                                                                                                                                              c,
 166                                                                                                                                                              cs
 167                                                                                                                                                              #) = readNext inp
 168                                                                                                                                                        in if (GHC.Classes.==) 'f' c
 169                                                                                                                                                             then
 170                                                                                                                                                               let _ = "lift2Value checkedHorizon=4"
 171                                                                                                                                                                in let _ = "comment: satisfy ((GHC.Classes.==) 'g')"
 172                                                                                                                                                                    in let _ = "checkHorizon.oldCheck: checkedHorizon=4"
 173                                                                                                                                                                        in let _ = "checkToken"
 174                                                                                                                                                                            in let !(#
 175                                                                                                                                                                                      c,
 176                                                                                                                                                                                      cs
 177                                                                                                                                                                                      #) = readNext cs
 178                                                                                                                                                                                in if (GHC.Classes.==) 'g' c
 179                                                                                                                                                                                     then
 180                                                                                                                                                                                       let _ = "lift2Value checkedHorizon=3"
 181                                                                                                                                                                                        in let _ = "comment: satisfy ((GHC.Classes.==) 'h')"
 182                                                                                                                                                                                            in let _ = "checkHorizon.oldCheck: checkedHorizon=3"
 183                                                                                                                                                                                                in let _ = "checkToken"
 184                                                                                                                                                                                                    in let !(#
 185                                                                                                                                                                                                              c,
 186                                                                                                                                                                                                              cs
 187                                                                                                                                                                                                              #) = readNext cs
 188                                                                                                                                                                                                        in if (GHC.Classes.==) 'h' c
 189                                                                                                                                                                                                             then
 190                                                                                                                                                                                                               let _ = "lift2Value checkedHorizon=2"
 191                                                                                                                                                                                                                in let _ = "comment: satisfy ((GHC.Classes.==) 'i')"
 192                                                                                                                                                                                                                    in let _ = "checkHorizon.oldCheck: checkedHorizon=2"
 193                                                                                                                                                                                                                        in let _ = "checkToken"
 194                                                                                                                                                                                                                            in let !(#
 195                                                                                                                                                                                                                                      c,
 196                                                                                                                                                                                                                                      cs
 197                                                                                                                                                                                                                                      #) = readNext cs
 198                                                                                                                                                                                                                                in if (GHC.Classes.==) 'i' c
 199                                                                                                                                                                                                                                     then
 200                                                                                                                                                                                                                                       let _ = "lift2Value checkedHorizon=1"
 201                                                                                                                                                                                                                                        in let _ = "commit"
 202                                                                                                                                                                                                                                            in let _ = "resume"
 203                                                                                                                                                                                                                                                in join
 204                                                                                                                                                                                                                                                     farInp
 205                                                                                                                                                                                                                                                     farExp
 206                                                                                                                                                                                                                                                     ( let _ = "resume.genCode"
 207                                                                                                                                                                                                                                                        in (GHC.Types.:) 'f' ((GHC.Types.:) 'g' ((GHC.Types.:) 'h' ((GHC.Types.:) 'i' GHC.Types . [])))
 208                                                                                                                                                                                                                                                     )
 209                                                                                                                                                                                                                                                     cs
 210                                                                                                                                                                                                                                     else
 211                                                                                                                                                                                                                                       let _ = "checkToken.fail"
 212                                                                                                                                                                                                                                        in let failExp =
 213                                                                                                                                                                                                                                                 Data.Set.Internal.Bin
 214                                                                                                                                                                                                                                                   1
 215                                                                                                                                                                                                                                                   ( Symantic.Parser.Grammar.Combinators.SomeFailure
 216                                                                                                                                                                                                                                                       ( case inputToken of
 217                                                                                                                                                                                                                                                           (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'i'
 218                                                                                                                                                                                                                                                       )
 219                                                                                                                                                                                                                                                   )
 220                                                                                                                                                                                                                                                   Data.Set.Internal.Tip
 221                                                                                                                                                                                                                                                   Data.Set.Internal.Tip
 222                                                                                                                                                                                                                                            in let (#
 223                                                                                                                                                                                                                                                     farInp,
 224                                                                                                                                                                                                                                                     farExp
 225                                                                                                                                                                                                                                                     #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp cs of
 226                                                                                                                                                                                                                                                       GHC.Types.LT ->
 227                                                                                                                                                                                                                                                         (#
 228                                                                                                                                                                                                                                                           cs,
 229                                                                                                                                                                                                                                                           failExp
 230                                                                                                                                                                                                                                                         #)
 231                                                                                                                                                                                                                                                       GHC.Types.EQ ->
 232                                                                                                                                                                                                                                                         (#
 233                                                                                                                                                                                                                                                           farInp,
 234                                                                                                                                                                                                                                                           failExp GHC.Base.<> farExp
 235                                                                                                                                                                                                                                                         #)
 236                                                                                                                                                                                                                                                       GHC.Types.GT ->
 237                                                                                                                                                                                                                                                         (#
 238                                                                                                                                                                                                                                                           farInp,
 239                                                                                                                                                                                                                                                           farExp
 240                                                                                                                                                                                                                                                         #)
 241                                                                                                                                                                                                                                                in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure cs farInp farExp
 242                                                                                                                                                                                                             else
 243                                                                                                                                                                                                               let _ = "checkToken.fail"
 244                                                                                                                                                                                                                in let failExp =
 245                                                                                                                                                                                                                         Data.Set.Internal.Bin
 246                                                                                                                                                                                                                           1
 247                                                                                                                                                                                                                           ( Symantic.Parser.Grammar.Combinators.SomeFailure
 248                                                                                                                                                                                                                               ( case inputToken of
 249                                                                                                                                                                                                                                   (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'h'
 250                                                                                                                                                                                                                               )
 251                                                                                                                                                                                                                           )
 252                                                                                                                                                                                                                           Data.Set.Internal.Tip
 253                                                                                                                                                                                                                           Data.Set.Internal.Tip
 254                                                                                                                                                                                                                    in let (#
 255                                                                                                                                                                                                                             farInp,
 256                                                                                                                                                                                                                             farExp
 257                                                                                                                                                                                                                             #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp cs of
 258                                                                                                                                                                                                                               GHC.Types.LT ->
 259                                                                                                                                                                                                                                 (#
 260                                                                                                                                                                                                                                   cs,
 261                                                                                                                                                                                                                                   failExp
 262                                                                                                                                                                                                                                 #)
 263                                                                                                                                                                                                                               GHC.Types.EQ ->
 264                                                                                                                                                                                                                                 (#
 265                                                                                                                                                                                                                                   farInp,
 266                                                                                                                                                                                                                                   failExp GHC.Base.<> farExp
 267                                                                                                                                                                                                                                 #)
 268                                                                                                                                                                                                                               GHC.Types.GT ->
 269                                                                                                                                                                                                                                 (#
 270                                                                                                                                                                                                                                   farInp,
 271                                                                                                                                                                                                                                   farExp
 272                                                                                                                                                                                                                                 #)
 273                                                                                                                                                                                                                        in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure cs farInp farExp
 274                                                                                                                                                                                     else
 275                                                                                                                                                                                       let _ = "checkToken.fail"
 276                                                                                                                                                                                        in let failExp =
 277                                                                                                                                                                                                 Data.Set.Internal.Bin
 278                                                                                                                                                                                                   1
 279                                                                                                                                                                                                   ( Symantic.Parser.Grammar.Combinators.SomeFailure
 280                                                                                                                                                                                                       ( case inputToken of
 281                                                                                                                                                                                                           (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'g'
 282                                                                                                                                                                                                       )
 283                                                                                                                                                                                                   )
 284                                                                                                                                                                                                   Data.Set.Internal.Tip
 285                                                                                                                                                                                                   Data.Set.Internal.Tip
 286                                                                                                                                                                                            in let (#
 287                                                                                                                                                                                                     farInp,
 288                                                                                                                                                                                                     farExp
 289                                                                                                                                                                                                     #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp cs of
 290                                                                                                                                                                                                       GHC.Types.LT ->
 291                                                                                                                                                                                                         (#
 292                                                                                                                                                                                                           cs,
 293                                                                                                                                                                                                           failExp
 294                                                                                                                                                                                                         #)
 295                                                                                                                                                                                                       GHC.Types.EQ ->
 296                                                                                                                                                                                                         (#
 297                                                                                                                                                                                                           farInp,
 298                                                                                                                                                                                                           failExp GHC.Base.<> farExp
 299                                                                                                                                                                                                         #)
 300                                                                                                                                                                                                       GHC.Types.GT ->
 301                                                                                                                                                                                                         (#
 302                                                                                                                                                                                                           farInp,
 303                                                                                                                                                                                                           farExp
 304                                                                                                                                                                                                         #)
 305                                                                                                                                                                                                in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure cs farInp farExp
 306                                                                                                                                                             else
 307                                                                                                                                                               let _ = "checkToken.fail"
 308                                                                                                                                                                in let failExp =
 309                                                                                                                                                                         Data.Set.Internal.Bin
 310                                                                                                                                                                           1
 311                                                                                                                                                                           ( Symantic.Parser.Grammar.Combinators.SomeFailure
 312                                                                                                                                                                               ( case inputToken of
 313                                                                                                                                                                                   (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'f'
 314                                                                                                                                                                               )
 315                                                                                                                                                                           )
 316                                                                                                                                                                           Data.Set.Internal.Tip
 317                                                                                                                                                                           Data.Set.Internal.Tip
 318                                                                                                                                                                    in let (#
 319                                                                                                                                                                             farInp,
 320                                                                                                                                                                             farExp
 321                                                                                                                                                                             #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp inp of
 322                                                                                                                                                                               GHC.Types.LT ->
 323                                                                                                                                                                                 (#
 324                                                                                                                                                                                   inp,
 325                                                                                                                                                                                   failExp
 326                                                                                                                                                                                 #)
 327                                                                                                                                                                               GHC.Types.EQ ->
 328                                                                                                                                                                                 (#
 329                                                                                                                                                                                   farInp,
 330                                                                                                                                                                                   failExp GHC.Base.<> farExp
 331                                                                                                                                                                                 #)
 332                                                                                                                                                                               GHC.Types.GT ->
 333                                                                                                                                                                                 (#
 334                                                                                                                                                                                   farInp,
 335                                                                                                                                                                                   farExp
 336                                                                                                                                                                                 #)
 337                                                                                                                                                                        in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp
 338                                                                                                                                                 else
 339                                                                                                                                                   let _ = "checkHorizon.newCheck.fail"
 340                                                                                                                                                    in let failExp =
 341                                                                                                                                                             Data.Set.Internal.Bin
 342                                                                                                                                                               1
 343                                                                                                                                                               ( Symantic.Parser.Grammar.Combinators.SomeFailure
 344                                                                                                                                                                   ( case inputToken of
 345                                                                                                                                                                       (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 4
 346                                                                                                                                                                   )
 347                                                                                                                                                               )
 348                                                                                                                                                               Data.Set.Internal.Tip
 349                                                                                                                                                               Data.Set.Internal.Tip
 350                                                                                                                                                        in let (#
 351                                                                                                                                                                 farInp,
 352                                                                                                                                                                 farExp
 353                                                                                                                                                                 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp inp of
 354                                                                                                                                                                   GHC.Types.LT ->
 355                                                                                                                                                                     (#
 356                                                                                                                                                                       inp,
 357                                                                                                                                                                       failExp
 358                                                                                                                                                                     #)
 359                                                                                                                                                                   GHC.Types.EQ ->
 360                                                                                                                                                                     (#
 361                                                                                                                                                                       farInp,
 362                                                                                                                                                                       failExp GHC.Base.<> farExp
 363                                                                                                                                                                     #)
 364                                                                                                                                                                   GHC.Types.GT ->
 365                                                                                                                                                                     (#
 366                                                                                                                                                                       farInp,
 367                                                                                                                                                                       farExp
 368                                                                                                                                                                     #)
 369                                                                                                                                                            in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp
 370                                                                                                             else
 371                                                                                                               let _ = "choicesBranch.else"
 372                                                                                                                in finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp
 373                                                                                    in let _ = "catch ExceptionFailure checkedHorizon=0"
 374                                                                                        in let onException =
 375                                                                                                 let _ = "onException"
 376                                                                                                  in \(!_exn) (!failInp) (!farInp) (!farExp) ->
 377                                                                                                       let _ = "loadInput checkedHorizon=0"
 378                                                                                                        in let _ = "checkHorizon.noCheck"
 379                                                                                                            in onException Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp
 380                                                                                            in let _ = "pushValue"
 381                                                                                                in let _ = "comment: satisfy ((GHC.Classes.==) 'd')"
 382                                                                                                    in let inp = failInp
 383                                                                                                        in let readFail = onException
 384                                                                                                            in let _ = "checkHorizon.newCheck: checkedHorizon=0 minHoriz=2"
 385                                                                                                                in if readMore (Symantic.Parser.Machine.Input.shiftRightText 1 inp)
 386                                                                                                                     then
 387                                                                                                                       let _ = "checkToken"
 388                                                                                                                        in let !(#
 389                                                                                                                                  c,
 390                                                                                                                                  cs
 391                                                                                                                                  #) = readNext inp
 392                                                                                                                            in if (GHC.Classes.==) 'd' c
 393                                                                                                                                 then
 394                                                                                                                                   let _ = "lift2Value checkedHorizon=2"
 395                                                                                                                                    in let _ = "comment: satisfy ((GHC.Classes.==) 'e')"
 396                                                                                                                                        in let _ = "checkHorizon.oldCheck: checkedHorizon=2"
 397                                                                                                                                            in let _ = "checkToken"
 398                                                                                                                                                in let !(#
 399                                                                                                                                                          c,
 400                                                                                                                                                          cs
 401                                                                                                                                                          #) = readNext cs
 402                                                                                                                                                    in if (GHC.Classes.==) 'e' c
 403                                                                                                                                                         then
 404                                                                                                                                                           let _ = "lift2Value checkedHorizon=1"
 405                                                                                                                                                            in let _ = "commit"
 406                                                                                                                                                                in let _ = "commit"
 407                                                                                                                                                                    in let _ = "resume"
 408                                                                                                                                                                        in join
 409                                                                                                                                                                             farInp
 410                                                                                                                                                                             farExp
 411                                                                                                                                                                             ( let _ = "resume.genCode"
 412                                                                                                                                                                                in (GHC.Types.:) 'd' ((GHC.Types.:) 'e' GHC.Types . [])
 413                                                                                                                                                                             )
 414                                                                                                                                                                             cs
 415                                                                                                                                                         else
 416                                                                                                                                                           let _ = "checkToken.fail"
 417                                                                                                                                                            in let failExp =
 418                                                                                                                                                                     Data.Set.Internal.Bin
 419                                                                                                                                                                       1
 420                                                                                                                                                                       ( Symantic.Parser.Grammar.Combinators.SomeFailure
 421                                                                                                                                                                           ( case inputToken of
 422                                                                                                                                                                               (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'e'
 423                                                                                                                                                                           )
 424                                                                                                                                                                       )
 425                                                                                                                                                                       Data.Set.Internal.Tip
 426                                                                                                                                                                       Data.Set.Internal.Tip
 427                                                                                                                                                                in let (#
 428                                                                                                                                                                         farInp,
 429                                                                                                                                                                         farExp
 430                                                                                                                                                                         #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp cs of
 431                                                                                                                                                                           GHC.Types.LT ->
 432                                                                                                                                                                             (#
 433                                                                                                                                                                               cs,
 434                                                                                                                                                                               failExp
 435                                                                                                                                                                             #)
 436                                                                                                                                                                           GHC.Types.EQ ->
 437                                                                                                                                                                             (#
 438                                                                                                                                                                               farInp,
 439                                                                                                                                                                               failExp GHC.Base.<> farExp
 440                                                                                                                                                                             #)
 441                                                                                                                                                                           GHC.Types.GT ->
 442                                                                                                                                                                             (#
 443                                                                                                                                                                               farInp,
 444                                                                                                                                                                               farExp
 445                                                                                                                                                                             #)
 446                                                                                                                                                                    in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure cs farInp farExp
 447                                                                                                                                 else
 448                                                                                                                                   let _ = "checkToken.fail"
 449                                                                                                                                    in let failExp =
 450                                                                                                                                             Data.Set.Internal.Bin
 451                                                                                                                                               1
 452                                                                                                                                               ( Symantic.Parser.Grammar.Combinators.SomeFailure
 453                                                                                                                                                   ( case inputToken of
 454                                                                                                                                                       (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'd'
 455                                                                                                                                                   )
 456                                                                                                                                               )
 457                                                                                                                                               Data.Set.Internal.Tip
 458                                                                                                                                               Data.Set.Internal.Tip
 459                                                                                                                                        in let (#
 460                                                                                                                                                 farInp,
 461                                                                                                                                                 farExp
 462                                                                                                                                                 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp inp of
 463                                                                                                                                                   GHC.Types.LT ->
 464                                                                                                                                                     (#
 465                                                                                                                                                       inp,
 466                                                                                                                                                       failExp
 467                                                                                                                                                     #)
 468                                                                                                                                                   GHC.Types.EQ ->
 469                                                                                                                                                     (#
 470                                                                                                                                                       farInp,
 471                                                                                                                                                       failExp GHC.Base.<> farExp
 472                                                                                                                                                     #)
 473                                                                                                                                                   GHC.Types.GT ->
 474                                                                                                                                                     (#
 475                                                                                                                                                       farInp,
 476                                                                                                                                                       farExp
 477                                                                                                                                                     #)
 478                                                                                                                                            in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp
 479                                                                                                                     else
 480                                                                                                                       let _ = "checkHorizon.newCheck.fail"
 481                                                                                                                        in let failExp =
 482                                                                                                                                 Data.Set.Internal.Bin
 483                                                                                                                                   1
 484                                                                                                                                   ( Symantic.Parser.Grammar.Combinators.SomeFailure
 485                                                                                                                                       ( case inputToken of
 486                                                                                                                                           (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 2
 487                                                                                                                                       )
 488                                                                                                                                   )
 489                                                                                                                                   Data.Set.Internal.Tip
 490                                                                                                                                   Data.Set.Internal.Tip
 491                                                                                                                            in let (#
 492                                                                                                                                     farInp,
 493                                                                                                                                     farExp
 494                                                                                                                                     #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp inp of
 495                                                                                                                                       GHC.Types.LT ->
 496                                                                                                                                         (#
 497                                                                                                                                           inp,
 498                                                                                                                                           failExp
 499                                                                                                                                         #)
 500                                                                                                                                       GHC.Types.EQ ->
 501                                                                                                                                         (#
 502                                                                                                                                           farInp,
 503                                                                                                                                           failExp GHC.Base.<> farExp
 504                                                                                                                                         #)
 505                                                                                                                                       GHC.Types.GT ->
 506                                                                                                                                         (#
 507                                                                                                                                           farInp,
 508                                                                                                                                           farExp
 509                                                                                                                                         #)
 510                                                                                                                                in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp
 511                                                                         else
 512                                                                           let _ = "choicesBranch.else"
 513                                                                            in finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp
 514                                                in let _ = "catch ExceptionFailure checkedHorizon=2"
 515                                                    in let onException =
 516                                                             let _ = "onException"
 517                                                              in \(!_exn) (!failInp) (!farInp) (!farExp) ->
 518                                                                   let _ = "loadInput checkedHorizon=2"
 519                                                                    in let _ = "checkHorizon.oldCheck: checkedHorizon=2"
 520                                                                        in onException Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp
 521                                                        in let _ = "pushValue"
 522                                                            in let _ = "comment: satisfy ((GHC.Classes.==) 'a')"
 523                                                                in let _ = "checkHorizon.oldCheck: checkedHorizon=2"
 524                                                                    in let _ = "checkToken"
 525                                                                        in let !(#
 526                                                                                  c,
 527                                                                                  cs
 528                                                                                  #) = readNext inp
 529                                                                            in if (GHC.Classes.==) 'a' c
 530                                                                                 then
 531                                                                                   let _ = "lift2Value checkedHorizon=1"
 532                                                                                    in let _ = "comment: satisfy ((GHC.Classes.==) 'b')"
 533                                                                                        in let _ = "checkHorizon.oldCheck: checkedHorizon=1"
 534                                                                                            in let _ = "checkToken"
 535                                                                                                in let !(#
 536                                                                                                          c,
 537                                                                                                          cs
 538                                                                                                          #) = readNext cs
 539                                                                                                    in if (GHC.Classes.==) 'b' c
 540                                                                                                         then
 541                                                                                                           let _ = "lift2Value checkedHorizon=0"
 542                                                                                                            in let _ = "comment: satisfy ((GHC.Classes.==) 'c')"
 543                                                                                                                in let inp = cs
 544                                                                                                                    in let readFail = onException
 545                                                                                                                        in let _ = "checkHorizon.newCheck: checkedHorizon=0 minHoriz=1"
 546                                                                                                                            in if readMore inp
 547                                                                                                                                 then
 548                                                                                                                                   let _ = "checkToken"
 549                                                                                                                                    in let !(#
 550                                                                                                                                              c,
 551                                                                                                                                              cs
 552                                                                                                                                              #) = readNext inp
 553                                                                                                                                        in if (GHC.Classes.==) 'c' c
 554                                                                                                                                             then
 555                                                                                                                                               let _ = "lift2Value checkedHorizon=1"
 556                                                                                                                                                in let _ = "commit"
 557                                                                                                                                                    in let _ = "commit"
 558                                                                                                                                                        in let _ = "resume"
 559                                                                                                                                                            in join
 560                                                                                                                                                                 init
 561                                                                                                                                                                 Data.Set.Internal.empty
 562                                                                                                                                                                 ( let _ = "resume.genCode"
 563                                                                                                                                                                    in (GHC.Types.:) 'a' ((GHC.Types.:) 'b' ((GHC.Types.:) 'c' GHC.Types . []))
 564                                                                                                                                                                 )
 565                                                                                                                                                                 cs
 566                                                                                                                                             else
 567                                                                                                                                               let _ = "checkToken.fail"
 568                                                                                                                                                in let failExp =
 569                                                                                                                                                         Data.Set.Internal.Bin
 570                                                                                                                                                           1
 571                                                                                                                                                           ( Symantic.Parser.Grammar.Combinators.SomeFailure
 572                                                                                                                                                               ( case inputToken of
 573                                                                                                                                                                   (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'c'
 574                                                                                                                                                               )
 575                                                                                                                                                           )
 576                                                                                                                                                           Data.Set.Internal.Tip
 577                                                                                                                                                           Data.Set.Internal.Tip
 578                                                                                                                                                    in let (#
 579                                                                                                                                                             farInp,
 580                                                                                                                                                             farExp
 581                                                                                                                                                             #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of
 582                                                                                                                                                               GHC.Types.LT ->
 583                                                                                                                                                                 (#
 584                                                                                                                                                                   inp,
 585                                                                                                                                                                   failExp
 586                                                                                                                                                                 #)
 587                                                                                                                                                               GHC.Types.EQ ->
 588                                                                                                                                                                 (#
 589                                                                                                                                                                   init,
 590                                                                                                                                                                   failExp GHC.Base.<> Data.Set.Internal.empty
 591                                                                                                                                                                 #)
 592                                                                                                                                                               GHC.Types.GT ->
 593                                                                                                                                                                 (#
 594                                                                                                                                                                   init,
 595                                                                                                                                                                   Data.Set.Internal.empty
 596                                                                                                                                                                 #)
 597                                                                                                                                                        in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp
 598                                                                                                                                 else
 599                                                                                                                                   let _ = "checkHorizon.newCheck.fail"
 600                                                                                                                                    in let failExp =
 601                                                                                                                                             Data.Set.Internal.Bin
 602                                                                                                                                               1
 603                                                                                                                                               ( Symantic.Parser.Grammar.Combinators.SomeFailure
 604                                                                                                                                                   ( case inputToken of
 605                                                                                                                                                       (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 1
 606                                                                                                                                                   )
 607                                                                                                                                               )
 608                                                                                                                                               Data.Set.Internal.Tip
 609                                                                                                                                               Data.Set.Internal.Tip
 610                                                                                                                                        in let (#
 611                                                                                                                                                 farInp,
 612                                                                                                                                                 farExp
 613                                                                                                                                                 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of
 614                                                                                                                                                   GHC.Types.LT ->
 615                                                                                                                                                     (#
 616                                                                                                                                                       inp,
 617                                                                                                                                                       failExp
 618                                                                                                                                                     #)
 619                                                                                                                                                   GHC.Types.EQ ->
 620                                                                                                                                                     (#
 621                                                                                                                                                       init,
 622                                                                                                                                                       failExp GHC.Base.<> Data.Set.Internal.empty
 623                                                                                                                                                     #)
 624                                                                                                                                                   GHC.Types.GT ->
 625                                                                                                                                                     (#
 626                                                                                                                                                       init,
 627                                                                                                                                                       Data.Set.Internal.empty
 628                                                                                                                                                     #)
 629                                                                                                                                            in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp
 630                                                                                                         else
 631                                                                                                           let _ = "checkToken.fail"
 632                                                                                                            in let failExp =
 633                                                                                                                     Data.Set.Internal.Bin
 634                                                                                                                       1
 635                                                                                                                       ( Symantic.Parser.Grammar.Combinators.SomeFailure
 636                                                                                                                           ( case inputToken of
 637                                                                                                                               (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'b'
 638                                                                                                                           )
 639                                                                                                                       )
 640                                                                                                                       Data.Set.Internal.Tip
 641                                                                                                                       Data.Set.Internal.Tip
 642                                                                                                                in let (#
 643                                                                                                                         farInp,
 644                                                                                                                         farExp
 645                                                                                                                         #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init cs of
 646                                                                                                                           GHC.Types.LT ->
 647                                                                                                                             (#
 648                                                                                                                               cs,
 649                                                                                                                               failExp
 650                                                                                                                             #)
 651                                                                                                                           GHC.Types.EQ ->
 652                                                                                                                             (#
 653                                                                                                                               init,
 654                                                                                                                               failExp GHC.Base.<> Data.Set.Internal.empty
 655                                                                                                                             #)
 656                                                                                                                           GHC.Types.GT ->
 657                                                                                                                             (#
 658                                                                                                                               init,
 659                                                                                                                               Data.Set.Internal.empty
 660                                                                                                                             #)
 661                                                                                                                    in onException Symantic.Parser.Grammar.Combinators.ExceptionFailure cs farInp farExp
 662                                                                                 else
 663                                                                                   let _ = "checkToken.fail"
 664                                                                                    in let failExp =
 665                                                                                             Data.Set.Internal.Bin
 666                                                                                               1
 667                                                                                               ( Symantic.Parser.Grammar.Combinators.SomeFailure
 668                                                                                                   ( case inputToken of
 669                                                                                                       (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'a'
 670                                                                                                   )
 671                                                                                               )
 672                                                                                               Data.Set.Internal.Tip
 673                                                                                               Data.Set.Internal.Tip
 674                                                                                        in let (#
 675                                                                                                 farInp,
 676                                                                                                 farExp
 677                                                                                                 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of
 678                                                                                                   GHC.Types.LT ->
 679                                                                                                     (#
 680                                                                                                       inp,
 681                                                                                                       failExp
 682                                                                                                     #)
 683                                                                                                   GHC.Types.EQ ->
 684                                                                                                     (#
 685                                                                                                       init,
 686                                                                                                       failExp GHC.Base.<> Data.Set.Internal.empty
 687                                                                                                     #)
 688                                                                                                   GHC.Types.GT ->
 689                                                                                                     (#
 690                                                                                                       init,
 691                                                                                                       Data.Set.Internal.empty
 692                                                                                                     #)
 693                                                                                            in onException Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp
 694                             else
 695                               let _ = "checkHorizon.newCheck.fail"
 696                                in let failExp =
 697                                         Data.Set.Internal.Bin
 698                                           1
 699                                           ( Symantic.Parser.Grammar.Combinators.SomeFailure
 700                                               ( case inputToken of
 701                                                   (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 2
 702                                               )
 703                                           )
 704                                           Data.Set.Internal.Tip
 705                                           Data.Set.Internal.Tip
 706                                    in let (#
 707                                             farInp,
 708                                             farExp
 709                                             #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of
 710                                               GHC.Types.LT ->
 711                                                 (#
 712                                                   inp,
 713                                                   failExp
 714                                                 #)
 715                                               GHC.Types.EQ ->
 716                                                 (#
 717                                                   init,
 718                                                   failExp GHC.Base.<> Data.Set.Internal.empty
 719                                                 #)
 720                                               GHC.Types.GT ->
 721                                                 (#
 722                                                   init,
 723                                                   Data.Set.Internal.empty
 724                                                 #)
 725                                        in finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp
 726         )