test/Golden/Splice/G13.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    in let finalRet = \_farInp _farExp v _inp -> Data.Either.Right v
  31        in let finalRaise ::
  32                 forall b.
  33                 Symantic.Parser.Machine.Generate.Catcher
  34                   inp
  35                   b = \_failInp (!farInp) (!farExp) ->
  36                   Data.Either.Left
  37                     Symantic.Parser.Machine.Generate.ParsingErrorStandard
  38                       { Symantic.Parser.Machine.Generate.parsingErrorOffset = Symantic.Parser.Machine.Input.offset farInp,
  39                         Symantic.Parser.Machine.Generate.parsingErrorUnexpected =
  40                           if readMore farInp
  41                             then
  42                               GHC.Maybe.Just
  43                                 ( let (#
  44                                         c,
  45                                         _
  46                                         #) = readNext farInp
  47                                    in c
  48                                 )
  49                             else GHC.Maybe.Nothing,
  50                         Symantic.Parser.Machine.Generate.parsingErrorExpecting = Data.Set.Internal.fromList farExp
  51                       }
  52            in let name = \(!ok) (!inp) (!koByLabel) ->
  53                     name
  54                       ( let _ = "suspend"
  55                          in \farInp farExp v (!inp) ->
  56                               let _ = "resume"
  57                                in ok
  58                                     farInp
  59                                     farExp
  60                                     ( let _ = "resume.genCode"
  61                                        in GHC.Tuple . ()
  62                                     )
  63                                     inp
  64                       )
  65                       inp
  66                       Data.Map.Internal.Tip
  67                   name = \(!ok) (!inp) (!koByLabel) ->
  68                     name
  69                       ( let _ = "suspend"
  70                          in \farInp farExp v (!inp) ->
  71                               let _ = "resume"
  72                                in ok
  73                                     farInp
  74                                     farExp
  75                                     ( let _ = "resume.genCode"
  76                                        in v GHC.Types . []
  77                                     )
  78                                     inp
  79                       )
  80                       inp
  81                       Data.Map.Internal.Tip
  82                   name = \(!ok) (!inp) (!koByLabel) ->
  83                     let _ = "catchException lbl=fail"
  84                      in let catchHandler (!failInp) (!farInp) (!farExp) =
  85                               let _ = "catchException.ko lbl=fail"
  86                                in if ( \( Data.Text.Internal.Text
  87                                             _
  88                                             i
  89                                             _
  90                                           )
  91                                         ( Data.Text.Internal.Text
  92                                             _
  93                                             j
  94                                             _
  95                                           ) -> i GHC.Classes.== j
  96                                      )
  97                                     inp
  98                                     failInp
  99                                     then
 100                                       let _ = "choicesBranch.then"
 101                                        in let _ = "resume"
 102                                            in ok
 103                                                 farInp
 104                                                 farExp
 105                                                 ( let _ = "resume.genCode"
 106                                                    in \x -> x
 107                                                 )
 108                                                 failInp
 109                                     else
 110                                       let _ = "choicesBranch.else"
 111                                        in let (#
 112                                                 farInp,
 113                                                 farExp
 114                                                 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp failInp of
 115                                                   GHC.Types.LT ->
 116                                                     (#
 117                                                       failInp,
 118                                                       []
 119                                                     #)
 120                                                   GHC.Types.EQ ->
 121                                                     (#
 122                                                       farInp,
 123                                                       farExp GHC.Base.<> []
 124                                                     #)
 125                                                   GHC.Types.GT ->
 126                                                     (#
 127                                                       farInp,
 128                                                       farExp
 129                                                     #)
 130                                            in finalRaise failInp farInp farExp
 131                          in let join = \farInp farExp v (!inp) ->
 132                                   name
 133                                     ( let _ = "suspend"
 134                                        in \farInp farExp v (!inp) ->
 135                                             name
 136                                               ( let _ = "suspend"
 137                                                  in \farInp farExp v (!inp) ->
 138                                                       let _ = "resume"
 139                                                        in ok
 140                                                             farInp
 141                                                             farExp
 142                                                             ( let _ = "resume.genCode"
 143                                                                in \x -> v GHC.Types.: v x
 144                                                             )
 145                                                             inp
 146                                               )
 147                                               inp
 148                                               Data.Map.Internal.Tip
 149                                     )
 150                                     inp
 151                                     Data.Map.Internal.Tip
 152                              in let readFail = catchHandler
 153                                  in if readMore inp
 154                                       then
 155                                         let !(#
 156                                                c,
 157                                                cs
 158                                                #) = readNext inp
 159                                          in if (\x -> \x -> x) GHC.Types.True c
 160                                               then
 161                                                 if '>' GHC.Classes.== c
 162                                                   then
 163                                                     let _ = "choicesBranch.then"
 164                                                      in let readFail = readFail
 165                                                          in if readMore inp
 166                                                               then
 167                                                                 let !(#
 168                                                                        c,
 169                                                                        cs
 170                                                                        #) = readNext inp
 171                                                                  in if (\x -> \x -> x) GHC.Types.True c
 172                                                                       then
 173                                                                         let _ = "resume"
 174                                                                          in join init GHC.Types
 175                                                                               . []
 176                                                                                 ( let _ = "resume.genCode"
 177                                                                                    in Grammar.Brainfuck.RightPointer
 178                                                                                 )
 179                                                                                 cs
 180                                                                       else
 181                                                                         let _ = "checkToken.else"
 182                                                                          in let (#
 183                                                                                   farInp,
 184                                                                                   farExp
 185                                                                                   #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of
 186                                                                                     GHC.Types.LT ->
 187                                                                                       (#
 188                                                                                         inp,
 189                                                                                         []
 190                                                                                       #)
 191                                                                                     GHC.Types.EQ ->
 192                                                                                       (#
 193                                                                                         init,
 194                                                                                         GHC.Types . [] GHC.Base.<> []
 195                                                                                       #)
 196                                                                                     GHC.Types.GT ->
 197                                                                                       (#
 198                                                                                         init,
 199                                                                                         GHC.Types . []
 200                                                                                       #)
 201                                                                              in readFail inp farInp farExp
 202                                                               else
 203                                                                 let _ = "checkHorizon.else"
 204                                                                  in let (#
 205                                                                           farInp,
 206                                                                           farExp
 207                                                                           #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of
 208                                                                             GHC.Types.LT ->
 209                                                                               (#
 210                                                                                 inp,
 211                                                                                 [Symantic.Parser.Grammar.Combinators.ErrorItemHorizon 1]
 212                                                                               #)
 213                                                                             GHC.Types.EQ ->
 214                                                                               (#
 215                                                                                 init,
 216                                                                                 GHC.Types . [] GHC.Base.<> [Symantic.Parser.Grammar.Combinators.ErrorItemHorizon 1]
 217                                                                               #)
 218                                                                             GHC.Types.GT ->
 219                                                                               (#
 220                                                                                 init,
 221                                                                                 GHC.Types . []
 222                                                                               #)
 223                                                                      in readFail inp farInp farExp
 224                                                   else
 225                                                     let _ = "choicesBranch.else"
 226                                                      in if '<' GHC.Classes.== c
 227                                                           then
 228                                                             let _ = "choicesBranch.then"
 229                                                              in let readFail = readFail
 230                                                                  in if readMore inp
 231                                                                       then
 232                                                                         let !(#
 233                                                                                c,
 234                                                                                cs
 235                                                                                #) = readNext inp
 236                                                                          in if (\x -> \x -> x) GHC.Types.True c
 237                                                                               then
 238                                                                                 let _ = "resume"
 239                                                                                  in join init GHC.Types
 240                                                                                       . []
 241                                                                                         ( let _ = "resume.genCode"
 242                                                                                            in Grammar.Brainfuck.LeftPointer
 243                                                                                         )
 244                                                                                         cs
 245                                                                               else
 246                                                                                 let _ = "checkToken.else"
 247                                                                                  in let (#
 248                                                                                           farInp,
 249                                                                                           farExp
 250                                                                                           #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of
 251                                                                                             GHC.Types.LT ->
 252                                                                                               (#
 253                                                                                                 inp,
 254                                                                                                 []
 255                                                                                               #)
 256                                                                                             GHC.Types.EQ ->
 257                                                                                               (#
 258                                                                                                 init,
 259                                                                                                 GHC.Types . [] GHC.Base.<> []
 260                                                                                               #)
 261                                                                                             GHC.Types.GT ->
 262                                                                                               (#
 263                                                                                                 init,
 264                                                                                                 GHC.Types . []
 265                                                                                               #)
 266                                                                                      in readFail inp farInp farExp
 267                                                                       else
 268                                                                         let _ = "checkHorizon.else"
 269                                                                          in let (#
 270                                                                                   farInp,
 271                                                                                   farExp
 272                                                                                   #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of
 273                                                                                     GHC.Types.LT ->
 274                                                                                       (#
 275                                                                                         inp,
 276                                                                                         [Symantic.Parser.Grammar.Combinators.ErrorItemHorizon 1]
 277                                                                                       #)
 278                                                                                     GHC.Types.EQ ->
 279                                                                                       (#
 280                                                                                         init,
 281                                                                                         GHC.Types . [] GHC.Base.<> [Symantic.Parser.Grammar.Combinators.ErrorItemHorizon 1]
 282                                                                                       #)
 283                                                                                     GHC.Types.GT ->
 284                                                                                       (#
 285                                                                                         init,
 286                                                                                         GHC.Types . []
 287                                                                                       #)
 288                                                                              in readFail inp farInp farExp
 289                                                           else
 290                                                             let _ = "choicesBranch.else"
 291                                                              in if '+' GHC.Classes.== c
 292                                                                   then
 293                                                                     let _ = "choicesBranch.then"
 294                                                                      in let readFail = readFail
 295                                                                          in if readMore inp
 296                                                                               then
 297                                                                                 let !(#
 298                                                                                        c,
 299                                                                                        cs
 300                                                                                        #) = readNext inp
 301                                                                                  in if (\x -> \x -> x) GHC.Types.True c
 302                                                                                       then
 303                                                                                         let _ = "resume"
 304                                                                                          in join init GHC.Types
 305                                                                                               . []
 306                                                                                                 ( let _ = "resume.genCode"
 307                                                                                                    in Grammar.Brainfuck.Increment
 308                                                                                                 )
 309                                                                                                 cs
 310                                                                                       else
 311                                                                                         let _ = "checkToken.else"
 312                                                                                          in let (#
 313                                                                                                   farInp,
 314                                                                                                   farExp
 315                                                                                                   #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of
 316                                                                                                     GHC.Types.LT ->
 317                                                                                                       (#
 318                                                                                                         inp,
 319                                                                                                         []
 320                                                                                                       #)
 321                                                                                                     GHC.Types.EQ ->
 322                                                                                                       (#
 323                                                                                                         init,
 324                                                                                                         GHC.Types . [] GHC.Base.<> []
 325                                                                                                       #)
 326                                                                                                     GHC.Types.GT ->
 327                                                                                                       (#
 328                                                                                                         init,
 329                                                                                                         GHC.Types . []
 330                                                                                                       #)
 331                                                                                              in readFail inp farInp farExp
 332                                                                               else
 333                                                                                 let _ = "checkHorizon.else"
 334                                                                                  in let (#
 335                                                                                           farInp,
 336                                                                                           farExp
 337                                                                                           #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of
 338                                                                                             GHC.Types.LT ->
 339                                                                                               (#
 340                                                                                                 inp,
 341                                                                                                 [Symantic.Parser.Grammar.Combinators.ErrorItemHorizon 1]
 342                                                                                               #)
 343                                                                                             GHC.Types.EQ ->
 344                                                                                               (#
 345                                                                                                 init,
 346                                                                                                 GHC.Types . [] GHC.Base.<> [Symantic.Parser.Grammar.Combinators.ErrorItemHorizon 1]
 347                                                                                               #)
 348                                                                                             GHC.Types.GT ->
 349                                                                                               (#
 350                                                                                                 init,
 351                                                                                                 GHC.Types . []
 352                                                                                               #)
 353                                                                                      in readFail inp farInp farExp
 354                                                                   else
 355                                                                     let _ = "choicesBranch.else"
 356                                                                      in if '-' GHC.Classes.== c
 357                                                                           then
 358                                                                             let _ = "choicesBranch.then"
 359                                                                              in let readFail = readFail
 360                                                                                  in if readMore inp
 361                                                                                       then
 362                                                                                         let !(#
 363                                                                                                c,
 364                                                                                                cs
 365                                                                                                #) = readNext inp
 366                                                                                          in if (\x -> \x -> x) GHC.Types.True c
 367                                                                                               then
 368                                                                                                 let _ = "resume"
 369                                                                                                  in join init GHC.Types
 370                                                                                                       . []
 371                                                                                                         ( let _ = "resume.genCode"
 372                                                                                                            in Grammar.Brainfuck.Decrement
 373                                                                                                         )
 374                                                                                                         cs
 375                                                                                               else
 376                                                                                                 let _ = "checkToken.else"
 377                                                                                                  in let (#
 378                                                                                                           farInp,
 379                                                                                                           farExp
 380                                                                                                           #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of
 381                                                                                                             GHC.Types.LT ->
 382                                                                                                               (#
 383                                                                                                                 inp,
 384                                                                                                                 []
 385                                                                                                               #)
 386                                                                                                             GHC.Types.EQ ->
 387                                                                                                               (#
 388                                                                                                                 init,
 389                                                                                                                 GHC.Types . [] GHC.Base.<> []
 390                                                                                                               #)
 391                                                                                                             GHC.Types.GT ->
 392                                                                                                               (#
 393                                                                                                                 init,
 394                                                                                                                 GHC.Types . []
 395                                                                                                               #)
 396                                                                                                      in readFail inp farInp farExp
 397                                                                                       else
 398                                                                                         let _ = "checkHorizon.else"
 399                                                                                          in let (#
 400                                                                                                   farInp,
 401                                                                                                   farExp
 402                                                                                                   #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of
 403                                                                                                     GHC.Types.LT ->
 404                                                                                                       (#
 405                                                                                                         inp,
 406                                                                                                         [Symantic.Parser.Grammar.Combinators.ErrorItemHorizon 1]
 407                                                                                                       #)
 408                                                                                                     GHC.Types.EQ ->
 409                                                                                                       (#
 410                                                                                                         init,
 411                                                                                                         GHC.Types . [] GHC.Base.<> [Symantic.Parser.Grammar.Combinators.ErrorItemHorizon 1]
 412                                                                                                       #)
 413                                                                                                     GHC.Types.GT ->
 414                                                                                                       (#
 415                                                                                                         init,
 416                                                                                                         GHC.Types . []
 417                                                                                                       #)
 418                                                                                              in readFail inp farInp farExp
 419                                                                           else
 420                                                                             let _ = "choicesBranch.else"
 421                                                                              in if '.' GHC.Classes.== c
 422                                                                                   then
 423                                                                                     let _ = "choicesBranch.then"
 424                                                                                      in let readFail = readFail
 425                                                                                          in if readMore inp
 426                                                                                               then
 427                                                                                                 let !(#
 428                                                                                                        c,
 429                                                                                                        cs
 430                                                                                                        #) = readNext inp
 431                                                                                                  in if (\x -> \x -> x) GHC.Types.True c
 432                                                                                                       then
 433                                                                                                         let _ = "resume"
 434                                                                                                          in join init GHC.Types
 435                                                                                                               . []
 436                                                                                                                 ( let _ = "resume.genCode"
 437                                                                                                                    in Grammar.Brainfuck.Output
 438                                                                                                                 )
 439                                                                                                                 cs
 440                                                                                                       else
 441                                                                                                         let _ = "checkToken.else"
 442                                                                                                          in let (#
 443                                                                                                                   farInp,
 444                                                                                                                   farExp
 445                                                                                                                   #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of
 446                                                                                                                     GHC.Types.LT ->
 447                                                                                                                       (#
 448                                                                                                                         inp,
 449                                                                                                                         []
 450                                                                                                                       #)
 451                                                                                                                     GHC.Types.EQ ->
 452                                                                                                                       (#
 453                                                                                                                         init,
 454                                                                                                                         GHC.Types . [] GHC.Base.<> []
 455                                                                                                                       #)
 456                                                                                                                     GHC.Types.GT ->
 457                                                                                                                       (#
 458                                                                                                                         init,
 459                                                                                                                         GHC.Types . []
 460                                                                                                                       #)
 461                                                                                                              in readFail inp farInp farExp
 462                                                                                               else
 463                                                                                                 let _ = "checkHorizon.else"
 464                                                                                                  in let (#
 465                                                                                                           farInp,
 466                                                                                                           farExp
 467                                                                                                           #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of
 468                                                                                                             GHC.Types.LT ->
 469                                                                                                               (#
 470                                                                                                                 inp,
 471                                                                                                                 [Symantic.Parser.Grammar.Combinators.ErrorItemHorizon 1]
 472                                                                                                               #)
 473                                                                                                             GHC.Types.EQ ->
 474                                                                                                               (#
 475                                                                                                                 init,
 476                                                                                                                 GHC.Types . [] GHC.Base.<> [Symantic.Parser.Grammar.Combinators.ErrorItemHorizon 1]
 477                                                                                                               #)
 478                                                                                                             GHC.Types.GT ->
 479                                                                                                               (#
 480                                                                                                                 init,
 481                                                                                                                 GHC.Types . []
 482                                                                                                               #)
 483                                                                                                      in readFail inp farInp farExp
 484                                                                                   else
 485                                                                                     let _ = "choicesBranch.else"
 486                                                                                      in if ',' GHC.Classes.== c
 487                                                                                           then
 488                                                                                             let _ = "choicesBranch.then"
 489                                                                                              in let readFail = readFail
 490                                                                                                  in if readMore inp
 491                                                                                                       then
 492                                                                                                         let !(#
 493                                                                                                                c,
 494                                                                                                                cs
 495                                                                                                                #) = readNext inp
 496                                                                                                          in if (\x -> \x -> x) GHC.Types.True c
 497                                                                                                               then
 498                                                                                                                 let _ = "resume"
 499                                                                                                                  in join init GHC.Types
 500                                                                                                                       . []
 501                                                                                                                         ( let _ = "resume.genCode"
 502                                                                                                                            in Grammar.Brainfuck.Input
 503                                                                                                                         )
 504                                                                                                                         cs
 505                                                                                                               else
 506                                                                                                                 let _ = "checkToken.else"
 507                                                                                                                  in let (#
 508                                                                                                                           farInp,
 509                                                                                                                           farExp
 510                                                                                                                           #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of
 511                                                                                                                             GHC.Types.LT ->
 512                                                                                                                               (#
 513                                                                                                                                 inp,
 514                                                                                                                                 []
 515                                                                                                                               #)
 516                                                                                                                             GHC.Types.EQ ->
 517                                                                                                                               (#
 518                                                                                                                                 init,
 519                                                                                                                                 GHC.Types . [] GHC.Base.<> []
 520                                                                                                                               #)
 521                                                                                                                             GHC.Types.GT ->
 522                                                                                                                               (#
 523                                                                                                                                 init,
 524                                                                                                                                 GHC.Types . []
 525                                                                                                                               #)
 526                                                                                                                      in readFail inp farInp farExp
 527                                                                                                       else
 528                                                                                                         let _ = "checkHorizon.else"
 529                                                                                                          in let (#
 530                                                                                                                   farInp,
 531                                                                                                                   farExp
 532                                                                                                                   #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of
 533                                                                                                                     GHC.Types.LT ->
 534                                                                                                                       (#
 535                                                                                                                         inp,
 536                                                                                                                         [Symantic.Parser.Grammar.Combinators.ErrorItemHorizon 1]
 537                                                                                                                       #)
 538                                                                                                                     GHC.Types.EQ ->
 539                                                                                                                       (#
 540                                                                                                                         init,
 541                                                                                                                         GHC.Types . [] GHC.Base.<> [Symantic.Parser.Grammar.Combinators.ErrorItemHorizon 1]
 542                                                                                                                       #)
 543                                                                                                                     GHC.Types.GT ->
 544                                                                                                                       (#
 545                                                                                                                         init,
 546                                                                                                                         GHC.Types . []
 547                                                                                                                       #)
 548                                                                                                              in readFail inp farInp farExp
 549                                                                                           else
 550                                                                                             let _ = "choicesBranch.else"
 551                                                                                              in if '[' GHC.Classes.== c
 552                                                                                                   then
 553                                                                                                     let _ = "choicesBranch.then"
 554                                                                                                      in let readFail = readFail
 555                                                                                                          in if readMore (Symantic.Parser.Machine.Input.shiftRightText 1 inp)
 556                                                                                                               then
 557                                                                                                                 let !(#
 558                                                                                                                        c,
 559                                                                                                                        cs
 560                                                                                                                        #) = readNext inp
 561                                                                                                                  in if (\x -> \x -> x) GHC.Types.True c
 562                                                                                                                       then
 563                                                                                                                         name
 564                                                                                                                           ( let _ = "suspend"
 565                                                                                                                              in \farInp farExp v (!inp) ->
 566                                                                                                                                   name
 567                                                                                                                                     ( let _ = "suspend"
 568                                                                                                                                        in \farInp farExp v (!inp) ->
 569                                                                                                                                             let readFail = readFail
 570                                                                                                                                              in if readMore inp
 571                                                                                                                                                   then
 572                                                                                                                                                     let !(#
 573                                                                                                                                                            c,
 574                                                                                                                                                            cs
 575                                                                                                                                                            #) = readNext inp
 576                                                                                                                                                      in if (']' GHC.Classes.==) c
 577                                                                                                                                                           then
 578                                                                                                                                                             let _ = "resume"
 579                                                                                                                                                              in join
 580                                                                                                                                                                   farInp
 581                                                                                                                                                                   farExp
 582                                                                                                                                                                   ( let _ = "resume.genCode"
 583                                                                                                                                                                      in Grammar.Brainfuck.Loop v
 584                                                                                                                                                                   )
 585                                                                                                                                                                   cs
 586                                                                                                                                                           else
 587                                                                                                                                                             let _ = "checkToken.else"
 588                                                                                                                                                              in let (#
 589                                                                                                                                                                       farInp,
 590                                                                                                                                                                       farExp
 591                                                                                                                                                                       #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp inp of
 592                                                                                                                                                                         GHC.Types.LT ->
 593                                                                                                                                                                           (#
 594                                                                                                                                                                             inp,
 595                                                                                                                                                                             [Symantic.Parser.Grammar.Combinators.ErrorItemToken ']']
 596                                                                                                                                                                           #)
 597                                                                                                                                                                         GHC.Types.EQ ->
 598                                                                                                                                                                           (#
 599                                                                                                                                                                             farInp,
 600                                                                                                                                                                             farExp GHC.Base.<> [Symantic.Parser.Grammar.Combinators.ErrorItemToken ']']
 601                                                                                                                                                                           #)
 602                                                                                                                                                                         GHC.Types.GT ->
 603                                                                                                                                                                           (#
 604                                                                                                                                                                             farInp,
 605                                                                                                                                                                             farExp
 606                                                                                                                                                                           #)
 607                                                                                                                                                                  in readFail inp farInp farExp
 608                                                                                                                                                   else
 609                                                                                                                                                     let _ = "checkHorizon.else"
 610                                                                                                                                                      in let (#
 611                                                                                                                                                               farInp,
 612                                                                                                                                                               farExp
 613                                                                                                                                                               #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp inp of
 614                                                                                                                                                                 GHC.Types.LT ->
 615                                                                                                                                                                   (#
 616                                                                                                                                                                     inp,
 617                                                                                                                                                                     [Symantic.Parser.Grammar.Combinators.ErrorItemHorizon 1]
 618                                                                                                                                                                   #)
 619                                                                                                                                                                 GHC.Types.EQ ->
 620                                                                                                                                                                   (#
 621                                                                                                                                                                     farInp,
 622                                                                                                                                                                     farExp GHC.Base.<> [Symantic.Parser.Grammar.Combinators.ErrorItemHorizon 1]
 623                                                                                                                                                                   #)
 624                                                                                                                                                                 GHC.Types.GT ->
 625                                                                                                                                                                   (#
 626                                                                                                                                                                     farInp,
 627                                                                                                                                                                     farExp
 628                                                                                                                                                                   #)
 629                                                                                                                                                          in readFail inp farInp farExp
 630                                                                                                                                     )
 631                                                                                                                                     inp
 632                                                                                                                                     Data.Map.Internal.Tip
 633                                                                                                                           )
 634                                                                                                                           cs
 635                                                                                                                           Data.Map.Internal.Tip
 636                                                                                                                       else
 637                                                                                                                         let _ = "checkToken.else"
 638                                                                                                                          in let (#
 639                                                                                                                                   farInp,
 640                                                                                                                                   farExp
 641                                                                                                                                   #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of
 642                                                                                                                                     GHC.Types.LT ->
 643                                                                                                                                       (#
 644                                                                                                                                         inp,
 645                                                                                                                                         []
 646                                                                                                                                       #)
 647                                                                                                                                     GHC.Types.EQ ->
 648                                                                                                                                       (#
 649                                                                                                                                         init,
 650                                                                                                                                         GHC.Types . [] GHC.Base.<> []
 651                                                                                                                                       #)
 652                                                                                                                                     GHC.Types.GT ->
 653                                                                                                                                       (#
 654                                                                                                                                         init,
 655                                                                                                                                         GHC.Types . []
 656                                                                                                                                       #)
 657                                                                                                                              in readFail inp farInp farExp
 658                                                                                                               else
 659                                                                                                                 let _ = "checkHorizon.else"
 660                                                                                                                  in let (#
 661                                                                                                                           farInp,
 662                                                                                                                           farExp
 663                                                                                                                           #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of
 664                                                                                                                             GHC.Types.LT ->
 665                                                                                                                               (#
 666                                                                                                                                 inp,
 667                                                                                                                                 [Symantic.Parser.Grammar.Combinators.ErrorItemHorizon 2]
 668                                                                                                                               #)
 669                                                                                                                             GHC.Types.EQ ->
 670                                                                                                                               (#
 671                                                                                                                                 init,
 672                                                                                                                                 GHC.Types . [] GHC.Base.<> [Symantic.Parser.Grammar.Combinators.ErrorItemHorizon 2]
 673                                                                                                                               #)
 674                                                                                                                             GHC.Types.GT ->
 675                                                                                                                               (#
 676                                                                                                                                 init,
 677                                                                                                                                 GHC.Types . []
 678                                                                                                                               #)
 679                                                                                                                      in readFail inp farInp farExp
 680                                                                                                   else
 681                                                                                                     let _ = "choicesBranch.else"
 682                                                                                                      in let (#
 683                                                                                                               farInp,
 684                                                                                                               farExp
 685                                                                                                               #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of
 686                                                                                                                 GHC.Types.LT ->
 687                                                                                                                   (#
 688                                                                                                                     inp,
 689                                                                                                                     []
 690                                                                                                                   #)
 691                                                                                                                 GHC.Types.EQ ->
 692                                                                                                                   (#
 693                                                                                                                     init,
 694                                                                                                                     GHC.Types . [] GHC.Base.<> []
 695                                                                                                                   #)
 696                                                                                                                 GHC.Types.GT ->
 697                                                                                                                   (#
 698                                                                                                                     init,
 699                                                                                                                     GHC.Types . []
 700                                                                                                                   #)
 701                                                                                                          in readFail inp farInp farExp
 702                                               else
 703                                                 let _ = "checkToken.else"
 704                                                  in let (#
 705                                                           farInp,
 706                                                           farExp
 707                                                           #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of
 708                                                             GHC.Types.LT ->
 709                                                               (#
 710                                                                 inp,
 711                                                                 []
 712                                                               #)
 713                                                             GHC.Types.EQ ->
 714                                                               (#
 715                                                                 init,
 716                                                                 GHC.Types . [] GHC.Base.<> []
 717                                                               #)
 718                                                             GHC.Types.GT ->
 719                                                               (#
 720                                                                 init,
 721                                                                 GHC.Types . []
 722                                                               #)
 723                                                      in readFail inp farInp farExp
 724                                       else
 725                                         let _ = "checkHorizon.else"
 726                                          in let (#
 727                                                   farInp,
 728                                                   farExp
 729                                                   #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of
 730                                                     GHC.Types.LT ->
 731                                                       (#
 732                                                         inp,
 733                                                         [Symantic.Parser.Grammar.Combinators.ErrorItemHorizon 1]
 734                                                       #)
 735                                                     GHC.Types.EQ ->
 736                                                       (#
 737                                                         init,
 738                                                         GHC.Types . [] GHC.Base.<> [Symantic.Parser.Grammar.Combinators.ErrorItemHorizon 1]
 739                                                       #)
 740                                                     GHC.Types.GT ->
 741                                                       (#
 742                                                         init,
 743                                                         GHC.Types . []
 744                                                       #)
 745                                              in readFail inp farInp farExp
 746                   name = \(!ok) (!inp) (!koByLabel) ->
 747                     let _ = "catchException lbl=fail"
 748                      in let catchHandler (!failInp) (!farInp) (!farExp) =
 749                               let _ = "catchException.ko lbl=fail"
 750                                in if ( \( Data.Text.Internal.Text
 751                                             _
 752                                             i
 753                                             _
 754                                           )
 755                                         ( Data.Text.Internal.Text
 756                                             _
 757                                             j
 758                                             _
 759                                           ) -> i GHC.Classes.== j
 760                                      )
 761                                     inp
 762                                     failInp
 763                                     then
 764                                       let _ = "choicesBranch.then"
 765                                        in let _ = "resume"
 766                                            in ok
 767                                                 farInp
 768                                                 farExp
 769                                                 ( let _ = "resume.genCode"
 770                                                    in \x -> x
 771                                                 )
 772                                                 failInp
 773                                     else
 774                                       let _ = "choicesBranch.else"
 775                                        in let (#
 776                                                 farInp,
 777                                                 farExp
 778                                                 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp failInp of
 779                                                   GHC.Types.LT ->
 780                                                     (#
 781                                                       failInp,
 782                                                       []
 783                                                     #)
 784                                                   GHC.Types.EQ ->
 785                                                     (#
 786                                                       farInp,
 787                                                       farExp GHC.Base.<> []
 788                                                     #)
 789                                                   GHC.Types.GT ->
 790                                                     (#
 791                                                       farInp,
 792                                                       farExp
 793                                                     #)
 794                                            in finalRaise failInp farInp farExp
 795                          in let readFail = catchHandler
 796                              in if readMore inp
 797                                   then
 798                                     let !(#
 799                                            c,
 800                                            cs
 801                                            #) = readNext inp
 802                                      in if (\c -> GHC.Classes.not (('<' GHC.Classes.== c) GHC.Classes.|| (('>' GHC.Classes.== c) GHC.Classes.|| (('+' GHC.Classes.== c) GHC.Classes.|| (('-' GHC.Classes.== c) GHC.Classes.|| (('[' GHC.Classes.== c) GHC.Classes.|| ((']' GHC.Classes.== c) GHC.Classes.|| ((',' GHC.Classes.== c) GHC.Classes.|| (('.' GHC.Classes.== c) GHC.Classes.|| (('$' GHC.Classes.== c) GHC.Classes.|| GHC.Types.False)))))))))) c
 803                                           then
 804                                             name
 805                                               ( let _ = "suspend"
 806                                                  in \farInp farExp v (!inp) ->
 807                                                       let _ = "resume"
 808                                                        in ok
 809                                                             farInp
 810                                                             farExp
 811                                                             ( let _ = "resume.genCode"
 812                                                                in \x -> v x
 813                                                             )
 814                                                             inp
 815                                               )
 816                                               cs
 817                                               Data.Map.Internal.Tip
 818                                           else
 819                                             let _ = "checkToken.else"
 820                                              in let (#
 821                                                       farInp,
 822                                                       farExp
 823                                                       #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of
 824                                                         GHC.Types.LT ->
 825                                                           (#
 826                                                             inp,
 827                                                             [ Symantic.Parser.Grammar.Combinators.ErrorItemToken '<',
 828                                                               Symantic.Parser.Grammar.Combinators.ErrorItemToken '>',
 829                                                               Symantic.Parser.Grammar.Combinators.ErrorItemToken '+',
 830                                                               Symantic.Parser.Grammar.Combinators.ErrorItemToken '-',
 831                                                               Symantic.Parser.Grammar.Combinators.ErrorItemToken '[',
 832                                                               Symantic.Parser.Grammar.Combinators.ErrorItemToken ']',
 833                                                               Symantic.Parser.Grammar.Combinators.ErrorItemToken ',',
 834                                                               Symantic.Parser.Grammar.Combinators.ErrorItemToken '.',
 835                                                               Symantic.Parser.Grammar.Combinators.ErrorItemToken '$'
 836                                                             ]
 837                                                           #)
 838                                                         GHC.Types.EQ ->
 839                                                           (#
 840                                                             init,
 841                                                             GHC.Types . []
 842                                                               GHC.Base.<> [ Symantic.Parser.Grammar.Combinators.ErrorItemToken '<',
 843                                                                             Symantic.Parser.Grammar.Combinators.ErrorItemToken '>',
 844                                                                             Symantic.Parser.Grammar.Combinators.ErrorItemToken '+',
 845                                                                             Symantic.Parser.Grammar.Combinators.ErrorItemToken '-',
 846                                                                             Symantic.Parser.Grammar.Combinators.ErrorItemToken '[',
 847                                                                             Symantic.Parser.Grammar.Combinators.ErrorItemToken ']',
 848                                                                             Symantic.Parser.Grammar.Combinators.ErrorItemToken ',',
 849                                                                             Symantic.Parser.Grammar.Combinators.ErrorItemToken '.',
 850                                                                             Symantic.Parser.Grammar.Combinators.ErrorItemToken '$'
 851                                                                           ]
 852                                                           #)
 853                                                         GHC.Types.GT ->
 854                                                           (#
 855                                                             init,
 856                                                             GHC.Types . []
 857                                                           #)
 858                                                  in readFail inp farInp farExp
 859                                   else
 860                                     let _ = "checkHorizon.else"
 861                                      in let (#
 862                                               farInp,
 863                                               farExp
 864                                               #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of
 865                                                 GHC.Types.LT ->
 866                                                   (#
 867                                                     inp,
 868                                                     [Symantic.Parser.Grammar.Combinators.ErrorItemHorizon 1]
 869                                                   #)
 870                                                 GHC.Types.EQ ->
 871                                                   (#
 872                                                     init,
 873                                                     GHC.Types . [] GHC.Base.<> [Symantic.Parser.Grammar.Combinators.ErrorItemHorizon 1]
 874                                                   #)
 875                                                 GHC.Types.GT ->
 876                                                   (#
 877                                                     init,
 878                                                     GHC.Types . []
 879                                                   #)
 880                                          in readFail inp farInp farExp
 881                in name
 882                     ( let _ = "suspend"
 883                        in \farInp farExp v (!inp) ->
 884                             name
 885                               ( let _ = "suspend"
 886                                  in \farInp farExp v (!inp) ->
 887                                       let _ = "resume"
 888                                        in finalRet
 889                                             farInp
 890                                             farExp
 891                                             ( let _ = "resume.genCode"
 892                                                in GHC.Show.show v
 893                                             )
 894                                             inp
 895                               )
 896                               inp
 897                               Data.Map.Internal.Tip
 898                     )
 899                     init
 900                     Data.Map.Internal.Tip