test/Golden/Splice/G13.expected.txt

   1 \(input_0 :: inp_6989586621679059048) ->
   2   let !(#
   3          init_1,
   4          readMore_2,
   5          readNext_3
   6          #) =
   7           let _ = "cursorOf"
   8            in let next_4
   9                     ( t_5@( Data.Text.Internal.Text
  10                               arr_6
  11                               off_7
  12                               unconsumed_8
  13                             )
  14                       ) =
  15                       let !( Data.Text.Unsafe.Iter
  16                                c_9
  17                                d_10
  18                              ) = Data.Text.Unsafe.iter t_5 0
  19                        in (#
  20                             c_9,
  21                             Data.Text.Internal.Text arr_6 (off_7 GHC.Num.+ d_10) (unconsumed_8 GHC.Num.- d_10)
  22                           #)
  23                   more_11
  24                     ( Data.Text.Internal.Text
  25                         _
  26                         _
  27                         unconsumed_12
  28                       ) = unconsumed_12 GHC.Classes.> 0
  29                in (#
  30                     input_0,
  31                     more_11,
  32                     next_4
  33                   #)
  34    in let finalRet_13 = \_farInp_14 _farExp_15 v_16 _inp_17 -> Data.Either.Right v_16
  35        in let finalRaise_18 ::
  36                 forall b_19.
  37                 Symantic.Parser.Machine.Generate.Catcher
  38                   inp_6989586621679059048
  39                   b_19 = \_failInp_20 (!farInp_21) (!farExp_22) ->
  40                   Data.Either.Left
  41                     Symantic.Parser.Machine.Generate.ParsingErrorStandard
  42                       { Symantic.Parser.Machine.Generate.parsingErrorOffset = Symantic.Parser.Machine.Input.offset farInp_21,
  43                         Symantic.Parser.Machine.Generate.parsingErrorUnexpected =
  44                           if readMore_2 farInp_21
  45                             then
  46                               GHC.Maybe.Just
  47                                 ( let (#
  48                                         c_23,
  49                                         _
  50                                         #) = readNext_3 farInp_21
  51                                    in c_23
  52                                 )
  53                             else GHC.Maybe.Nothing,
  54                         Symantic.Parser.Machine.Generate.parsingErrorExpecting = Data.Set.Internal.fromList farExp_22
  55                       }
  56            in let name_24 = \(!ok_25) (!inp_26) (!koByLabel_27) ->
  57                     name_28
  58                       ( let _ = "suspend"
  59                          in \farInp_29 farExp_30 v_31 (!inp_32) ->
  60                               let _ = "resume"
  61                                in ok_25
  62                                     farInp_29
  63                                     farExp_30
  64                                     ( let _ = "resume.genCode"
  65                                        in GHC.Tuple . ()
  66                                     )
  67                                     inp_32
  68                       )
  69                       inp_26
  70                       Data.Map.Internal.Tip
  71                   name_28 = \(!ok_33) (!inp_34) (!koByLabel_35) ->
  72                     let _ = "catchException lbl=fail"
  73                      in let catchHandler_36 (!failInp_37) (!farInp_38) (!farExp_39) =
  74                               let _ = "catchException.ko lbl=fail"
  75                                in if ( \( Data.Text.Internal.Text
  76                                             _
  77                                             i_40
  78                                             _
  79                                           )
  80                                         ( Data.Text.Internal.Text
  81                                             _
  82                                             j_41
  83                                             _
  84                                           ) -> i_40 GHC.Classes.== j_41
  85                                      )
  86                                     inp_34
  87                                     failInp_37
  88                                     then
  89                                       let _ = "choicesBranch.then"
  90                                        in let _ = "resume"
  91                                            in ok_33
  92                                                 farInp_38
  93                                                 farExp_39
  94                                                 ( let _ = "resume.genCode"
  95                                                    in \x_42 -> x_42
  96                                                 )
  97                                                 failInp_37
  98                                     else
  99                                       let _ = "choicesBranch.else"
 100                                        in let (#
 101                                                 farInp_43,
 102                                                 farExp_44
 103                                                 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp_38 failInp_37 of
 104                                                   GHC.Types.LT ->
 105                                                     (#
 106                                                       failInp_37,
 107                                                       []
 108                                                     #)
 109                                                   GHC.Types.EQ ->
 110                                                     (#
 111                                                       farInp_38,
 112                                                       farExp_39 GHC.Base.<> []
 113                                                     #)
 114                                                   GHC.Types.GT ->
 115                                                     (#
 116                                                       farInp_38,
 117                                                       farExp_39
 118                                                     #)
 119                                            in finalRaise_18 failInp_37 farInp_43 farExp_44
 120                          in let readFail_45 = catchHandler_36
 121                              in if readMore_2 inp_34
 122                                   then
 123                                     let !(#
 124                                            c_46,
 125                                            cs_47
 126                                            #) = readNext_3 inp_34
 127                                      in if (\c_48 -> GHC.Classes.not (('<' GHC.Classes.== c_48) GHC.Classes.|| (('>' GHC.Classes.== c_48) GHC.Classes.|| (('+' GHC.Classes.== c_48) GHC.Classes.|| (('-' GHC.Classes.== c_48) GHC.Classes.|| (('[' GHC.Classes.== c_48) GHC.Classes.|| ((']' GHC.Classes.== c_48) GHC.Classes.|| ((',' GHC.Classes.== c_48) GHC.Classes.|| (('.' GHC.Classes.== c_48) GHC.Classes.|| (('$' GHC.Classes.== c_48) GHC.Classes.|| GHC.Types.False)))))))))) c_46
 128                                           then
 129                                             name_28
 130                                               ( let _ = "suspend"
 131                                                  in \farInp_49 farExp_50 v_51 (!inp_52) ->
 132                                                       let _ = "resume"
 133                                                        in ok_33
 134                                                             farInp_49
 135                                                             farExp_50
 136                                                             ( let _ = "resume.genCode"
 137                                                                in \x_53 -> v_51 x_53
 138                                                             )
 139                                                             inp_52
 140                                               )
 141                                               cs_47
 142                                               Data.Map.Internal.Tip
 143                                           else
 144                                             let _ = "checkToken.else"
 145                                              in let (#
 146                                                       farInp_54,
 147                                                       farExp_55
 148                                                       #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init_1 inp_34 of
 149                                                         GHC.Types.LT ->
 150                                                           (#
 151                                                             inp_34,
 152                                                             [ Symantic.Parser.Grammar.Combinators.ErrorItemToken '<',
 153                                                               Symantic.Parser.Grammar.Combinators.ErrorItemToken '>',
 154                                                               Symantic.Parser.Grammar.Combinators.ErrorItemToken '+',
 155                                                               Symantic.Parser.Grammar.Combinators.ErrorItemToken '-',
 156                                                               Symantic.Parser.Grammar.Combinators.ErrorItemToken '[',
 157                                                               Symantic.Parser.Grammar.Combinators.ErrorItemToken ']',
 158                                                               Symantic.Parser.Grammar.Combinators.ErrorItemToken ',',
 159                                                               Symantic.Parser.Grammar.Combinators.ErrorItemToken '.',
 160                                                               Symantic.Parser.Grammar.Combinators.ErrorItemToken '$'
 161                                                             ]
 162                                                           #)
 163                                                         GHC.Types.EQ ->
 164                                                           (#
 165                                                             init_1,
 166                                                             GHC.Types . []
 167                                                               GHC.Base.<> [ Symantic.Parser.Grammar.Combinators.ErrorItemToken '<',
 168                                                                             Symantic.Parser.Grammar.Combinators.ErrorItemToken '>',
 169                                                                             Symantic.Parser.Grammar.Combinators.ErrorItemToken '+',
 170                                                                             Symantic.Parser.Grammar.Combinators.ErrorItemToken '-',
 171                                                                             Symantic.Parser.Grammar.Combinators.ErrorItemToken '[',
 172                                                                             Symantic.Parser.Grammar.Combinators.ErrorItemToken ']',
 173                                                                             Symantic.Parser.Grammar.Combinators.ErrorItemToken ',',
 174                                                                             Symantic.Parser.Grammar.Combinators.ErrorItemToken '.',
 175                                                                             Symantic.Parser.Grammar.Combinators.ErrorItemToken '$'
 176                                                                           ]
 177                                                           #)
 178                                                         GHC.Types.GT ->
 179                                                           (#
 180                                                             init_1,
 181                                                             GHC.Types . []
 182                                                           #)
 183                                                  in readFail_45 inp_34 farInp_54 farExp_55
 184                                   else
 185                                     let _ = "checkHorizon.else"
 186                                      in let (#
 187                                               farInp_56,
 188                                               farExp_57
 189                                               #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init_1 inp_34 of
 190                                                 GHC.Types.LT ->
 191                                                   (#
 192                                                     inp_34,
 193                                                     [Symantic.Parser.Grammar.Combinators.ErrorItemHorizon 1]
 194                                                   #)
 195                                                 GHC.Types.EQ ->
 196                                                   (#
 197                                                     init_1,
 198                                                     GHC.Types . [] GHC.Base.<> [Symantic.Parser.Grammar.Combinators.ErrorItemHorizon 1]
 199                                                   #)
 200                                                 GHC.Types.GT ->
 201                                                   (#
 202                                                     init_1,
 203                                                     GHC.Types . []
 204                                                   #)
 205                                          in readFail_45 inp_34 farInp_56 farExp_57
 206                   name_58 = \(!ok_59) (!inp_60) (!koByLabel_61) ->
 207                     let _ = "catchException lbl=fail"
 208                      in let catchHandler_62 (!failInp_63) (!farInp_64) (!farExp_65) =
 209                               let _ = "catchException.ko lbl=fail"
 210                                in if ( \( Data.Text.Internal.Text
 211                                             _
 212                                             i_66
 213                                             _
 214                                           )
 215                                         ( Data.Text.Internal.Text
 216                                             _
 217                                             j_67
 218                                             _
 219                                           ) -> i_66 GHC.Classes.== j_67
 220                                      )
 221                                     inp_60
 222                                     failInp_63
 223                                     then
 224                                       let _ = "choicesBranch.then"
 225                                        in let _ = "resume"
 226                                            in ok_59
 227                                                 farInp_64
 228                                                 farExp_65
 229                                                 ( let _ = "resume.genCode"
 230                                                    in \x_68 -> x_68
 231                                                 )
 232                                                 failInp_63
 233                                     else
 234                                       let _ = "choicesBranch.else"
 235                                        in let (#
 236                                                 farInp_69,
 237                                                 farExp_70
 238                                                 #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp_64 failInp_63 of
 239                                                   GHC.Types.LT ->
 240                                                     (#
 241                                                       failInp_63,
 242                                                       []
 243                                                     #)
 244                                                   GHC.Types.EQ ->
 245                                                     (#
 246                                                       farInp_64,
 247                                                       farExp_65 GHC.Base.<> []
 248                                                     #)
 249                                                   GHC.Types.GT ->
 250                                                     (#
 251                                                       farInp_64,
 252                                                       farExp_65
 253                                                     #)
 254                                            in finalRaise_18 failInp_63 farInp_69 farExp_70
 255                          in let join_71 = \farInp_72 farExp_73 v_74 (!inp_75) ->
 256                                   name_24
 257                                     ( let _ = "suspend"
 258                                        in \farInp_76 farExp_77 v_78 (!inp_79) ->
 259                                             name_58
 260                                               ( let _ = "suspend"
 261                                                  in \farInp_80 farExp_81 v_82 (!inp_83) ->
 262                                                       let _ = "resume"
 263                                                        in ok_59
 264                                                             farInp_80
 265                                                             farExp_81
 266                                                             ( let _ = "resume.genCode"
 267                                                                in \x_84 -> v_74 GHC.Types.: v_82 x_84
 268                                                             )
 269                                                             inp_83
 270                                               )
 271                                               inp_79
 272                                               Data.Map.Internal.Tip
 273                                     )
 274                                     inp_75
 275                                     Data.Map.Internal.Tip
 276                              in let readFail_85 = catchHandler_62
 277                                  in if readMore_2 inp_60
 278                                       then
 279                                         let !(#
 280                                                c_86,
 281                                                cs_87
 282                                                #) = readNext_3 inp_60
 283                                          in if (\x_88 -> \x_89 -> x_88) GHC.Types.True c_86
 284                                               then
 285                                                 if '>' GHC.Classes.== c_86
 286                                                   then
 287                                                     let _ = "choicesBranch.then"
 288                                                      in let readFail_90 = readFail_85
 289                                                          in if readMore_2 inp_60
 290                                                               then
 291                                                                 let !(#
 292                                                                        c_91,
 293                                                                        cs_92
 294                                                                        #) = readNext_3 inp_60
 295                                                                  in if (\x_93 -> \x_94 -> x_93) GHC.Types.True c_91
 296                                                                       then
 297                                                                         let _ = "resume"
 298                                                                          in join_71 init_1 GHC.Types
 299                                                                               . []
 300                                                                                 ( let _ = "resume.genCode"
 301                                                                                    in Grammar.Brainfuck.RightPointer
 302                                                                                 )
 303                                                                                 cs_92
 304                                                                       else
 305                                                                         let _ = "checkToken.else"
 306                                                                          in let (#
 307                                                                                   farInp_95,
 308                                                                                   farExp_96
 309                                                                                   #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init_1 inp_60 of
 310                                                                                     GHC.Types.LT ->
 311                                                                                       (#
 312                                                                                         inp_60,
 313                                                                                         []
 314                                                                                       #)
 315                                                                                     GHC.Types.EQ ->
 316                                                                                       (#
 317                                                                                         init_1,
 318                                                                                         GHC.Types . [] GHC.Base.<> []
 319                                                                                       #)
 320                                                                                     GHC.Types.GT ->
 321                                                                                       (#
 322                                                                                         init_1,
 323                                                                                         GHC.Types . []
 324                                                                                       #)
 325                                                                              in readFail_90 inp_60 farInp_95 farExp_96
 326                                                               else
 327                                                                 let _ = "checkHorizon.else"
 328                                                                  in let (#
 329                                                                           farInp_97,
 330                                                                           farExp_98
 331                                                                           #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init_1 inp_60 of
 332                                                                             GHC.Types.LT ->
 333                                                                               (#
 334                                                                                 inp_60,
 335                                                                                 [Symantic.Parser.Grammar.Combinators.ErrorItemHorizon 1]
 336                                                                               #)
 337                                                                             GHC.Types.EQ ->
 338                                                                               (#
 339                                                                                 init_1,
 340                                                                                 GHC.Types . [] GHC.Base.<> [Symantic.Parser.Grammar.Combinators.ErrorItemHorizon 1]
 341                                                                               #)
 342                                                                             GHC.Types.GT ->
 343                                                                               (#
 344                                                                                 init_1,
 345                                                                                 GHC.Types . []
 346                                                                               #)
 347                                                                      in readFail_90 inp_60 farInp_97 farExp_98
 348                                                   else
 349                                                     let _ = "choicesBranch.else"
 350                                                      in if '<' GHC.Classes.== c_86
 351                                                           then
 352                                                             let _ = "choicesBranch.then"
 353                                                              in let readFail_99 = readFail_85
 354                                                                  in if readMore_2 inp_60
 355                                                                       then
 356                                                                         let !(#
 357                                                                                c_100,
 358                                                                                cs_101
 359                                                                                #) = readNext_3 inp_60
 360                                                                          in if (\x_102 -> \x_103 -> x_102) GHC.Types.True c_100
 361                                                                               then
 362                                                                                 let _ = "resume"
 363                                                                                  in join_71 init_1 GHC.Types
 364                                                                                       . []
 365                                                                                         ( let _ = "resume.genCode"
 366                                                                                            in Grammar.Brainfuck.LeftPointer
 367                                                                                         )
 368                                                                                         cs_101
 369                                                                               else
 370                                                                                 let _ = "checkToken.else"
 371                                                                                  in let (#
 372                                                                                           farInp_104,
 373                                                                                           farExp_105
 374                                                                                           #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init_1 inp_60 of
 375                                                                                             GHC.Types.LT ->
 376                                                                                               (#
 377                                                                                                 inp_60,
 378                                                                                                 []
 379                                                                                               #)
 380                                                                                             GHC.Types.EQ ->
 381                                                                                               (#
 382                                                                                                 init_1,
 383                                                                                                 GHC.Types . [] GHC.Base.<> []
 384                                                                                               #)
 385                                                                                             GHC.Types.GT ->
 386                                                                                               (#
 387                                                                                                 init_1,
 388                                                                                                 GHC.Types . []
 389                                                                                               #)
 390                                                                                      in readFail_99 inp_60 farInp_104 farExp_105
 391                                                                       else
 392                                                                         let _ = "checkHorizon.else"
 393                                                                          in let (#
 394                                                                                   farInp_106,
 395                                                                                   farExp_107
 396                                                                                   #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init_1 inp_60 of
 397                                                                                     GHC.Types.LT ->
 398                                                                                       (#
 399                                                                                         inp_60,
 400                                                                                         [Symantic.Parser.Grammar.Combinators.ErrorItemHorizon 1]
 401                                                                                       #)
 402                                                                                     GHC.Types.EQ ->
 403                                                                                       (#
 404                                                                                         init_1,
 405                                                                                         GHC.Types . [] GHC.Base.<> [Symantic.Parser.Grammar.Combinators.ErrorItemHorizon 1]
 406                                                                                       #)
 407                                                                                     GHC.Types.GT ->
 408                                                                                       (#
 409                                                                                         init_1,
 410                                                                                         GHC.Types . []
 411                                                                                       #)
 412                                                                              in readFail_99 inp_60 farInp_106 farExp_107
 413                                                           else
 414                                                             let _ = "choicesBranch.else"
 415                                                              in if '+' GHC.Classes.== c_86
 416                                                                   then
 417                                                                     let _ = "choicesBranch.then"
 418                                                                      in let readFail_108 = readFail_85
 419                                                                          in if readMore_2 inp_60
 420                                                                               then
 421                                                                                 let !(#
 422                                                                                        c_109,
 423                                                                                        cs_110
 424                                                                                        #) = readNext_3 inp_60
 425                                                                                  in if (\x_111 -> \x_112 -> x_111) GHC.Types.True c_109
 426                                                                                       then
 427                                                                                         let _ = "resume"
 428                                                                                          in join_71 init_1 GHC.Types
 429                                                                                               . []
 430                                                                                                 ( let _ = "resume.genCode"
 431                                                                                                    in Grammar.Brainfuck.Increment
 432                                                                                                 )
 433                                                                                                 cs_110
 434                                                                                       else
 435                                                                                         let _ = "checkToken.else"
 436                                                                                          in let (#
 437                                                                                                   farInp_113,
 438                                                                                                   farExp_114
 439                                                                                                   #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init_1 inp_60 of
 440                                                                                                     GHC.Types.LT ->
 441                                                                                                       (#
 442                                                                                                         inp_60,
 443                                                                                                         []
 444                                                                                                       #)
 445                                                                                                     GHC.Types.EQ ->
 446                                                                                                       (#
 447                                                                                                         init_1,
 448                                                                                                         GHC.Types . [] GHC.Base.<> []
 449                                                                                                       #)
 450                                                                                                     GHC.Types.GT ->
 451                                                                                                       (#
 452                                                                                                         init_1,
 453                                                                                                         GHC.Types . []
 454                                                                                                       #)
 455                                                                                              in readFail_108 inp_60 farInp_113 farExp_114
 456                                                                               else
 457                                                                                 let _ = "checkHorizon.else"
 458                                                                                  in let (#
 459                                                                                           farInp_115,
 460                                                                                           farExp_116
 461                                                                                           #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init_1 inp_60 of
 462                                                                                             GHC.Types.LT ->
 463                                                                                               (#
 464                                                                                                 inp_60,
 465                                                                                                 [Symantic.Parser.Grammar.Combinators.ErrorItemHorizon 1]
 466                                                                                               #)
 467                                                                                             GHC.Types.EQ ->
 468                                                                                               (#
 469                                                                                                 init_1,
 470                                                                                                 GHC.Types . [] GHC.Base.<> [Symantic.Parser.Grammar.Combinators.ErrorItemHorizon 1]
 471                                                                                               #)
 472                                                                                             GHC.Types.GT ->
 473                                                                                               (#
 474                                                                                                 init_1,
 475                                                                                                 GHC.Types . []
 476                                                                                               #)
 477                                                                                      in readFail_108 inp_60 farInp_115 farExp_116
 478                                                                   else
 479                                                                     let _ = "choicesBranch.else"
 480                                                                      in if '-' GHC.Classes.== c_86
 481                                                                           then
 482                                                                             let _ = "choicesBranch.then"
 483                                                                              in let readFail_117 = readFail_85
 484                                                                                  in if readMore_2 inp_60
 485                                                                                       then
 486                                                                                         let !(#
 487                                                                                                c_118,
 488                                                                                                cs_119
 489                                                                                                #) = readNext_3 inp_60
 490                                                                                          in if (\x_120 -> \x_121 -> x_120) GHC.Types.True c_118
 491                                                                                               then
 492                                                                                                 let _ = "resume"
 493                                                                                                  in join_71 init_1 GHC.Types
 494                                                                                                       . []
 495                                                                                                         ( let _ = "resume.genCode"
 496                                                                                                            in Grammar.Brainfuck.Decrement
 497                                                                                                         )
 498                                                                                                         cs_119
 499                                                                                               else
 500                                                                                                 let _ = "checkToken.else"
 501                                                                                                  in let (#
 502                                                                                                           farInp_122,
 503                                                                                                           farExp_123
 504                                                                                                           #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init_1 inp_60 of
 505                                                                                                             GHC.Types.LT ->
 506                                                                                                               (#
 507                                                                                                                 inp_60,
 508                                                                                                                 []
 509                                                                                                               #)
 510                                                                                                             GHC.Types.EQ ->
 511                                                                                                               (#
 512                                                                                                                 init_1,
 513                                                                                                                 GHC.Types . [] GHC.Base.<> []
 514                                                                                                               #)
 515                                                                                                             GHC.Types.GT ->
 516                                                                                                               (#
 517                                                                                                                 init_1,
 518                                                                                                                 GHC.Types . []
 519                                                                                                               #)
 520                                                                                                      in readFail_117 inp_60 farInp_122 farExp_123
 521                                                                                       else
 522                                                                                         let _ = "checkHorizon.else"
 523                                                                                          in let (#
 524                                                                                                   farInp_124,
 525                                                                                                   farExp_125
 526                                                                                                   #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init_1 inp_60 of
 527                                                                                                     GHC.Types.LT ->
 528                                                                                                       (#
 529                                                                                                         inp_60,
 530                                                                                                         [Symantic.Parser.Grammar.Combinators.ErrorItemHorizon 1]
 531                                                                                                       #)
 532                                                                                                     GHC.Types.EQ ->
 533                                                                                                       (#
 534                                                                                                         init_1,
 535                                                                                                         GHC.Types . [] GHC.Base.<> [Symantic.Parser.Grammar.Combinators.ErrorItemHorizon 1]
 536                                                                                                       #)
 537                                                                                                     GHC.Types.GT ->
 538                                                                                                       (#
 539                                                                                                         init_1,
 540                                                                                                         GHC.Types . []
 541                                                                                                       #)
 542                                                                                              in readFail_117 inp_60 farInp_124 farExp_125
 543                                                                           else
 544                                                                             let _ = "choicesBranch.else"
 545                                                                              in if '.' GHC.Classes.== c_86
 546                                                                                   then
 547                                                                                     let _ = "choicesBranch.then"
 548                                                                                      in let readFail_126 = readFail_85
 549                                                                                          in if readMore_2 inp_60
 550                                                                                               then
 551                                                                                                 let !(#
 552                                                                                                        c_127,
 553                                                                                                        cs_128
 554                                                                                                        #) = readNext_3 inp_60
 555                                                                                                  in if (\x_129 -> \x_130 -> x_129) GHC.Types.True c_127
 556                                                                                                       then
 557                                                                                                         let _ = "resume"
 558                                                                                                          in join_71 init_1 GHC.Types
 559                                                                                                               . []
 560                                                                                                                 ( let _ = "resume.genCode"
 561                                                                                                                    in Grammar.Brainfuck.Output
 562                                                                                                                 )
 563                                                                                                                 cs_128
 564                                                                                                       else
 565                                                                                                         let _ = "checkToken.else"
 566                                                                                                          in let (#
 567                                                                                                                   farInp_131,
 568                                                                                                                   farExp_132
 569                                                                                                                   #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init_1 inp_60 of
 570                                                                                                                     GHC.Types.LT ->
 571                                                                                                                       (#
 572                                                                                                                         inp_60,
 573                                                                                                                         []
 574                                                                                                                       #)
 575                                                                                                                     GHC.Types.EQ ->
 576                                                                                                                       (#
 577                                                                                                                         init_1,
 578                                                                                                                         GHC.Types . [] GHC.Base.<> []
 579                                                                                                                       #)
 580                                                                                                                     GHC.Types.GT ->
 581                                                                                                                       (#
 582                                                                                                                         init_1,
 583                                                                                                                         GHC.Types . []
 584                                                                                                                       #)
 585                                                                                                              in readFail_126 inp_60 farInp_131 farExp_132
 586                                                                                               else
 587                                                                                                 let _ = "checkHorizon.else"
 588                                                                                                  in let (#
 589                                                                                                           farInp_133,
 590                                                                                                           farExp_134
 591                                                                                                           #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init_1 inp_60 of
 592                                                                                                             GHC.Types.LT ->
 593                                                                                                               (#
 594                                                                                                                 inp_60,
 595                                                                                                                 [Symantic.Parser.Grammar.Combinators.ErrorItemHorizon 1]
 596                                                                                                               #)
 597                                                                                                             GHC.Types.EQ ->
 598                                                                                                               (#
 599                                                                                                                 init_1,
 600                                                                                                                 GHC.Types . [] GHC.Base.<> [Symantic.Parser.Grammar.Combinators.ErrorItemHorizon 1]
 601                                                                                                               #)
 602                                                                                                             GHC.Types.GT ->
 603                                                                                                               (#
 604                                                                                                                 init_1,
 605                                                                                                                 GHC.Types . []
 606                                                                                                               #)
 607                                                                                                      in readFail_126 inp_60 farInp_133 farExp_134
 608                                                                                   else
 609                                                                                     let _ = "choicesBranch.else"
 610                                                                                      in if ',' GHC.Classes.== c_86
 611                                                                                           then
 612                                                                                             let _ = "choicesBranch.then"
 613                                                                                              in let readFail_135 = readFail_85
 614                                                                                                  in if readMore_2 inp_60
 615                                                                                                       then
 616                                                                                                         let !(#
 617                                                                                                                c_136,
 618                                                                                                                cs_137
 619                                                                                                                #) = readNext_3 inp_60
 620                                                                                                          in if (\x_138 -> \x_139 -> x_138) GHC.Types.True c_136
 621                                                                                                               then
 622                                                                                                                 let _ = "resume"
 623                                                                                                                  in join_71 init_1 GHC.Types
 624                                                                                                                       . []
 625                                                                                                                         ( let _ = "resume.genCode"
 626                                                                                                                            in Grammar.Brainfuck.Input
 627                                                                                                                         )
 628                                                                                                                         cs_137
 629                                                                                                               else
 630                                                                                                                 let _ = "checkToken.else"
 631                                                                                                                  in let (#
 632                                                                                                                           farInp_140,
 633                                                                                                                           farExp_141
 634                                                                                                                           #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init_1 inp_60 of
 635                                                                                                                             GHC.Types.LT ->
 636                                                                                                                               (#
 637                                                                                                                                 inp_60,
 638                                                                                                                                 []
 639                                                                                                                               #)
 640                                                                                                                             GHC.Types.EQ ->
 641                                                                                                                               (#
 642                                                                                                                                 init_1,
 643                                                                                                                                 GHC.Types . [] GHC.Base.<> []
 644                                                                                                                               #)
 645                                                                                                                             GHC.Types.GT ->
 646                                                                                                                               (#
 647                                                                                                                                 init_1,
 648                                                                                                                                 GHC.Types . []
 649                                                                                                                               #)
 650                                                                                                                      in readFail_135 inp_60 farInp_140 farExp_141
 651                                                                                                       else
 652                                                                                                         let _ = "checkHorizon.else"
 653                                                                                                          in let (#
 654                                                                                                                   farInp_142,
 655                                                                                                                   farExp_143
 656                                                                                                                   #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init_1 inp_60 of
 657                                                                                                                     GHC.Types.LT ->
 658                                                                                                                       (#
 659                                                                                                                         inp_60,
 660                                                                                                                         [Symantic.Parser.Grammar.Combinators.ErrorItemHorizon 1]
 661                                                                                                                       #)
 662                                                                                                                     GHC.Types.EQ ->
 663                                                                                                                       (#
 664                                                                                                                         init_1,
 665                                                                                                                         GHC.Types . [] GHC.Base.<> [Symantic.Parser.Grammar.Combinators.ErrorItemHorizon 1]
 666                                                                                                                       #)
 667                                                                                                                     GHC.Types.GT ->
 668                                                                                                                       (#
 669                                                                                                                         init_1,
 670                                                                                                                         GHC.Types . []
 671                                                                                                                       #)
 672                                                                                                              in readFail_135 inp_60 farInp_142 farExp_143
 673                                                                                           else
 674                                                                                             let _ = "choicesBranch.else"
 675                                                                                              in if '[' GHC.Classes.== c_86
 676                                                                                                   then
 677                                                                                                     let _ = "choicesBranch.then"
 678                                                                                                      in let readFail_144 = readFail_85
 679                                                                                                          in if readMore_2 (Symantic.Parser.Machine.Input.shiftRightText 1 inp_60)
 680                                                                                                               then
 681                                                                                                                 let !(#
 682                                                                                                                        c_145,
 683                                                                                                                        cs_146
 684                                                                                                                        #) = readNext_3 inp_60
 685                                                                                                                  in if (\x_147 -> \x_148 -> x_147) GHC.Types.True c_145
 686                                                                                                                       then
 687                                                                                                                         name_24
 688                                                                                                                           ( let _ = "suspend"
 689                                                                                                                              in \farInp_149 farExp_150 v_151 (!inp_152) ->
 690                                                                                                                                   name_153
 691                                                                                                                                     ( let _ = "suspend"
 692                                                                                                                                        in \farInp_154 farExp_155 v_156 (!inp_157) ->
 693                                                                                                                                             let readFail_158 = readFail_144
 694                                                                                                                                              in if readMore_2 inp_157
 695                                                                                                                                                   then
 696                                                                                                                                                     let !(#
 697                                                                                                                                                            c_159,
 698                                                                                                                                                            cs_160
 699                                                                                                                                                            #) = readNext_3 inp_157
 700                                                                                                                                                      in if (']' GHC.Classes.==) c_159
 701                                                                                                                                                           then
 702                                                                                                                                                             let _ = "resume"
 703                                                                                                                                                              in join_71
 704                                                                                                                                                                   farInp_154
 705                                                                                                                                                                   farExp_155
 706                                                                                                                                                                   ( let _ = "resume.genCode"
 707                                                                                                                                                                      in Grammar.Brainfuck.Loop v_156
 708                                                                                                                                                                   )
 709                                                                                                                                                                   cs_160
 710                                                                                                                                                           else
 711                                                                                                                                                             let _ = "checkToken.else"
 712                                                                                                                                                              in let (#
 713                                                                                                                                                                       farInp_161,
 714                                                                                                                                                                       farExp_162
 715                                                                                                                                                                       #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp_154 inp_157 of
 716                                                                                                                                                                         GHC.Types.LT ->
 717                                                                                                                                                                           (#
 718                                                                                                                                                                             inp_157,
 719                                                                                                                                                                             [Symantic.Parser.Grammar.Combinators.ErrorItemToken ']']
 720                                                                                                                                                                           #)
 721                                                                                                                                                                         GHC.Types.EQ ->
 722                                                                                                                                                                           (#
 723                                                                                                                                                                             farInp_154,
 724                                                                                                                                                                             farExp_155 GHC.Base.<> [Symantic.Parser.Grammar.Combinators.ErrorItemToken ']']
 725                                                                                                                                                                           #)
 726                                                                                                                                                                         GHC.Types.GT ->
 727                                                                                                                                                                           (#
 728                                                                                                                                                                             farInp_154,
 729                                                                                                                                                                             farExp_155
 730                                                                                                                                                                           #)
 731                                                                                                                                                                  in readFail_158 inp_157 farInp_161 farExp_162
 732                                                                                                                                                   else
 733                                                                                                                                                     let _ = "checkHorizon.else"
 734                                                                                                                                                      in let (#
 735                                                                                                                                                               farInp_163,
 736                                                                                                                                                               farExp_164
 737                                                                                                                                                               #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp_154 inp_157 of
 738                                                                                                                                                                 GHC.Types.LT ->
 739                                                                                                                                                                   (#
 740                                                                                                                                                                     inp_157,
 741                                                                                                                                                                     [Symantic.Parser.Grammar.Combinators.ErrorItemHorizon 1]
 742                                                                                                                                                                   #)
 743                                                                                                                                                                 GHC.Types.EQ ->
 744                                                                                                                                                                   (#
 745                                                                                                                                                                     farInp_154,
 746                                                                                                                                                                     farExp_155 GHC.Base.<> [Symantic.Parser.Grammar.Combinators.ErrorItemHorizon 1]
 747                                                                                                                                                                   #)
 748                                                                                                                                                                 GHC.Types.GT ->
 749                                                                                                                                                                   (#
 750                                                                                                                                                                     farInp_154,
 751                                                                                                                                                                     farExp_155
 752                                                                                                                                                                   #)
 753                                                                                                                                                          in readFail_158 inp_157 farInp_163 farExp_164
 754                                                                                                                                     )
 755                                                                                                                                     inp_152
 756                                                                                                                                     Data.Map.Internal.Tip
 757                                                                                                                           )
 758                                                                                                                           cs_146
 759                                                                                                                           Data.Map.Internal.Tip
 760                                                                                                                       else
 761                                                                                                                         let _ = "checkToken.else"
 762                                                                                                                          in let (#
 763                                                                                                                                   farInp_165,
 764                                                                                                                                   farExp_166
 765                                                                                                                                   #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init_1 inp_60 of
 766                                                                                                                                     GHC.Types.LT ->
 767                                                                                                                                       (#
 768                                                                                                                                         inp_60,
 769                                                                                                                                         []
 770                                                                                                                                       #)
 771                                                                                                                                     GHC.Types.EQ ->
 772                                                                                                                                       (#
 773                                                                                                                                         init_1,
 774                                                                                                                                         GHC.Types . [] GHC.Base.<> []
 775                                                                                                                                       #)
 776                                                                                                                                     GHC.Types.GT ->
 777                                                                                                                                       (#
 778                                                                                                                                         init_1,
 779                                                                                                                                         GHC.Types . []
 780                                                                                                                                       #)
 781                                                                                                                              in readFail_144 inp_60 farInp_165 farExp_166
 782                                                                                                               else
 783                                                                                                                 let _ = "checkHorizon.else"
 784                                                                                                                  in let (#
 785                                                                                                                           farInp_167,
 786                                                                                                                           farExp_168
 787                                                                                                                           #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init_1 inp_60 of
 788                                                                                                                             GHC.Types.LT ->
 789                                                                                                                               (#
 790                                                                                                                                 inp_60,
 791                                                                                                                                 [Symantic.Parser.Grammar.Combinators.ErrorItemHorizon 2]
 792                                                                                                                               #)
 793                                                                                                                             GHC.Types.EQ ->
 794                                                                                                                               (#
 795                                                                                                                                 init_1,
 796                                                                                                                                 GHC.Types . [] GHC.Base.<> [Symantic.Parser.Grammar.Combinators.ErrorItemHorizon 2]
 797                                                                                                                               #)
 798                                                                                                                             GHC.Types.GT ->
 799                                                                                                                               (#
 800                                                                                                                                 init_1,
 801                                                                                                                                 GHC.Types . []
 802                                                                                                                               #)
 803                                                                                                                      in readFail_144 inp_60 farInp_167 farExp_168
 804                                                                                                   else
 805                                                                                                     let _ = "choicesBranch.else"
 806                                                                                                      in let (#
 807                                                                                                               farInp_169,
 808                                                                                                               farExp_170
 809                                                                                                               #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init_1 inp_60 of
 810                                                                                                                 GHC.Types.LT ->
 811                                                                                                                   (#
 812                                                                                                                     inp_60,
 813                                                                                                                     []
 814                                                                                                                   #)
 815                                                                                                                 GHC.Types.EQ ->
 816                                                                                                                   (#
 817                                                                                                                     init_1,
 818                                                                                                                     GHC.Types . [] GHC.Base.<> []
 819                                                                                                                   #)
 820                                                                                                                 GHC.Types.GT ->
 821                                                                                                                   (#
 822                                                                                                                     init_1,
 823                                                                                                                     GHC.Types . []
 824                                                                                                                   #)
 825                                                                                                          in readFail_85 inp_60 farInp_169 farExp_170
 826                                               else
 827                                                 let _ = "checkToken.else"
 828                                                  in let (#
 829                                                           farInp_171,
 830                                                           farExp_172
 831                                                           #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init_1 inp_60 of
 832                                                             GHC.Types.LT ->
 833                                                               (#
 834                                                                 inp_60,
 835                                                                 []
 836                                                               #)
 837                                                             GHC.Types.EQ ->
 838                                                               (#
 839                                                                 init_1,
 840                                                                 GHC.Types . [] GHC.Base.<> []
 841                                                               #)
 842                                                             GHC.Types.GT ->
 843                                                               (#
 844                                                                 init_1,
 845                                                                 GHC.Types . []
 846                                                               #)
 847                                                      in readFail_85 inp_60 farInp_171 farExp_172
 848                                       else
 849                                         let _ = "checkHorizon.else"
 850                                          in let (#
 851                                                   farInp_173,
 852                                                   farExp_174
 853                                                   #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init_1 inp_60 of
 854                                                     GHC.Types.LT ->
 855                                                       (#
 856                                                         inp_60,
 857                                                         [Symantic.Parser.Grammar.Combinators.ErrorItemHorizon 1]
 858                                                       #)
 859                                                     GHC.Types.EQ ->
 860                                                       (#
 861                                                         init_1,
 862                                                         GHC.Types . [] GHC.Base.<> [Symantic.Parser.Grammar.Combinators.ErrorItemHorizon 1]
 863                                                       #)
 864                                                     GHC.Types.GT ->
 865                                                       (#
 866                                                         init_1,
 867                                                         GHC.Types . []
 868                                                       #)
 869                                              in readFail_85 inp_60 farInp_173 farExp_174
 870                   name_153 = \(!ok_175) (!inp_176) (!koByLabel_177) ->
 871                     name_58
 872                       ( let _ = "suspend"
 873                          in \farInp_178 farExp_179 v_180 (!inp_181) ->
 874                               let _ = "resume"
 875                                in ok_175
 876                                     farInp_178
 877                                     farExp_179
 878                                     ( let _ = "resume.genCode"
 879                                        in v_180 GHC.Types . []
 880                                     )
 881                                     inp_181
 882                       )
 883                       inp_176
 884                       Data.Map.Internal.Tip
 885                in name_24
 886                     ( let _ = "suspend"
 887                        in \farInp_182 farExp_183 v_184 (!inp_185) ->
 888                             name_153
 889                               ( let _ = "suspend"
 890                                  in \farInp_186 farExp_187 v_188 (!inp_189) ->
 891                                       let _ = "resume"
 892                                        in finalRet_13
 893                                             farInp_186
 894                                             farExp_187
 895                                             ( let _ = "resume.genCode"
 896                                                in v_188
 897                                             )
 898                                             inp_189
 899                               )
 900                               inp_185
 901                               Data.Map.Internal.Tip
 902                     )
 903                     init_1
 904                     Data.Map.Internal.Tip