parsers/Parsers/Brainfuck/SymanticParser/DumpSplice.hs

   1 {-# LANGUAGE AllowAmbiguousTypes #-}
   2 {-# LANGUAGE ScopedTypeVariables #-}
   3 {-# LANGUAGE TemplateHaskell #-}
   4 {-# LANGUAGE TypeApplications #-}
   5 {-# LANGUAGE ViewPatterns #-}
   6 -- for Symantic.Parser's TemplateHaskell
   7 {-# LANGUAGE MagicHash #-}
   8 {-# LANGUAGE ScopedTypeVariables #-}
   9 {-# LANGUAGE RankNTypes #-}
  10 {-# LANGUAGE UnboxedTuples #-}
  11 {-# OPTIONS_GHC -Wno-unused-matches #-}
  12 {-# OPTIONS_GHC -Wno-unused-local-binds #-}
  13 module Parsers.Brainfuck.SymanticParser.DumpSplice where
  14
  15 import qualified Data.ByteString as BS
  16 import qualified Data.ByteString.Internal
  17 import qualified Data.Either
  18 import qualified Data.Function
  19 import qualified Data.Map.Internal
  20 import qualified Data.Map.Strict.Internal
  21 import qualified Data.Proxy
  22 import qualified Data.Set.Internal
  23 import qualified Data.Text.Internal
  24 import qualified Data.Text.Unsafe
  25 import qualified GHC.Base
  26 import qualified GHC.Classes
  27 import qualified GHC.ForeignPtr
  28 import qualified GHC.Maybe
  29 import qualified GHC.Num
  30 import qualified GHC.Prim
  31 import qualified GHC.Show
  32 import qualified GHC.Tuple
  33 import qualified GHC.Types
  34 import qualified GHC.Word
  35 import qualified Language.Haskell.TH as TH
  36 import qualified Language.Haskell.TH.Syntax as TH
  37 import qualified Prelude
  38 import qualified Symantic.Parser as SP
  39 import qualified Symantic.Parser.Grammar.Combinators
  40 import qualified Symantic.Parser.Haskell
  41 import qualified Symantic.Parser.Machine
  42 import qualified Symantic.Parser.Machine.Generate
  43 import qualified Symantic.Parser.Machine.Input
  44 import qualified System.IO as IO
  45 import Data.Either (Either)
  46
  47 import qualified Parsers.Brainfuck.Types
  48 import Parsers.Brainfuck.Types (Instruction)
  49
  50 -- The splice below has been manually paste with:
  51 -- :r dist-newstyle/build/x86_64-linux/ghc-9.0.1/symantic-parser-*/l/parsers/build/parsers/parsers/Parsers/Brainfuck/SymanticParser/AutoSplice.dump-splices
  52 -- :%s/\%x00//g
  53 -- :%s/#\(_[0-9]\+\)/\1#/g
  54 parserByteString :: BS.ByteString -> Either (SP.ParsingError BS.ByteString) [Instruction]
  55 parserByteString =
  56     \ (input_ama8 :: inp_a1S5K)
  57       -> let
  58            !(# init_amaa, readMore_amab, readNext_amac #)
  59              = let
  60                  !(Data.ByteString.Internal.PS (GHC.ForeignPtr.ForeignPtr addr_amae#
  61                                                                           final_amaf)
  62                                                off_amag size_amah)
  63                    = input_ama8
  64                  next_amai i_amaj@(GHC.Types.I# i_amak#)
  65                    = case
  66                          ((GHC.Prim.readWord8OffAddr#
  67                              (addr_amae# `GHC.Prim.plusAddr#` i_amak#))
  68                             0#)
  69                            GHC.Prim.realWorld#
  70                      of {
  71                        (# s'_amal, x_amam #)
  72                          -> case (GHC.Prim.touch# final_amaf) s'_amal of {
  73                               _ -> (# GHC.Word.W8# x_amam, (i_amaj GHC.Num.+ 1) #) } }
  74                in (# off_amag, (GHC.Classes.< size_amah), next_amai #)
  75            finalRet_ama9
  76              = \ _farInp_aman _farExp_amao v_amap _inp_amaq
  77                  -> Data.Either.Right v_amap
  78            finalRaise_amad :: forall b_amar. SP.Catcher inp_a1S5K b_amar
  79              = \ !exn_amas _failInp_amat !farInp_amau !farExp_amav
  80                  -> Data.Either.Left
  81                       SP.ParsingErrorStandard
  82                         {SP.parsingErrorOffset = SP.offset farInp_amau,
  83                          SP.parsingErrorException = exn_amas,
  84                          SP.parsingErrorUnexpected = if readMore_amab farInp_amau then
  85                                                          GHC.Maybe.Just
  86                                                            (let
  87                                                               (# c_amaw, _ #)
  88                                                                 = readNext_amac farInp_amau
  89                                                             in c_amaw)
  90                                                      else
  91                                                          GHC.Maybe.Nothing,
  92                          SP.parsingErrorExpecting = farExp_amav} in
  93          let
  94            inputToken
  95              = Data.Proxy.Proxy :: Data.Proxy.Proxy (SP.InputToken inp_a1S5K) in
  96          let
  97            name_1
  98              = \ !ok_amcU !inp_amcV !koByLabel_amcW
  99                  -> ((name_4
 100                         (let _ = "suspend"
 101                          in
 102                            \ farInp_amcX farExp_amcY v_amcZ !inp_amd0
 103                              -> let _ = "resume"
 104                                 in
 105                                   (((ok_amcU farInp_amcX) farExp_amcY)
 106                                      (let _ = "resume.genCode" in ()))
 107                                     inp_amd0))
 108                        inp_amcV)
 109                       (((((Data.Map.Internal.Bin 1) SP.ExceptionFailure)
 110                            (((Data.Map.Strict.Internal.findWithDefault finalRaise_amad)
 111                                SP.ExceptionFailure)
 112                               koByLabel_amcW))
 113                           Data.Map.Internal.Tip)
 114                          Data.Map.Internal.Tip)
 115            name_2
 116              = \ !ok_amcN !inp_amcO !koByLabel_amcP
 117                  -> ((name_3
 118                         (let _ = "suspend"
 119                          in
 120                            \ farInp_amcQ farExp_amcR v_amcS !inp_amcT
 121                              -> let _ = "resume"
 122                                 in
 123                                   (((ok_amcN farInp_amcQ) farExp_amcR)
 124                                      (let _ = "resume.genCode" in v_amcS []))
 125                                     inp_amcT))
 126                        inp_amcO)
 127                       (((((Data.Map.Internal.Bin 1) SP.ExceptionFailure)
 128                            (((Data.Map.Strict.Internal.findWithDefault finalRaise_amad)
 129                                SP.ExceptionFailure)
 130                               koByLabel_amcP))
 131                           Data.Map.Internal.Tip)
 132                          Data.Map.Internal.Tip)
 133            name_3
 134              = \ !ok_amaS !inp_amaT !koByLabel_amaU
 135                  -> let _ = "catch ExceptionFailure" in
 136                     let
 137                       catchHandler_amaV
 138                         !_exn_amaW
 139                         !failInp_amaX
 140                         !farInp_amaY
 141                         !farExp_amaZ
 142                         = let _ = "catch.ko ExceptionFailure"
 143                           in
 144                             if (((GHC.Classes.==) @GHC.Types.Int) inp_amaT) failInp_amaX then
 145                                 let _ = "choicesBranch.then" in
 146                                 let _ = "resume"
 147                                 in
 148                                   (((ok_amaS farInp_amaY) farExp_amaZ)
 149                                      (let _ = "resume.genCode" in \ x_amb0 -> x_amb0))
 150                                     failInp_amaX
 151                             else
 152                                 let _ = "choicesBranch.else"
 153                                 in
 154                                   ((((((Data.Map.Strict.Internal.findWithDefault finalRaise_amad)
 155                                          SP.ExceptionFailure)
 156                                         koByLabel_amaU)
 157                                        SP.ExceptionFailure)
 158                                       failInp_amaX)
 159                                      farInp_amaY)
 160                                     farExp_amaZ in
 161                     let
 162                       join_1s
 163                         = \ farInp_amb1 farExp_amb2 v_amb3 !inp_amb4
 164                             -> ((name_1
 165                                    (let _ = "suspend"
 166                                     in
 167                                       \ farInp_amb5 farExp_amb6 v_amb7 !inp_amb8
 168                                         -> ((name_3
 169                                                (let _ = "suspend"
 170                                                 in
 171                                                   \ farInp_amb9 farExp_amba v_ambb !inp_ambc
 172                                                     -> let _ = "resume"
 173                                                        in
 174                                                          (((ok_amaS farInp_amb9) farExp_amba)
 175                                                             (let _ = "resume.genCode"
 176                                                              in
 177                                                                \ x_ambd
 178                                                                  -> (v_amb3 : v_ambb x_ambd)))
 179                                                            inp_ambc))
 180                                               inp_amb8)
 181                                              (((((Data.Map.Internal.Bin 1) SP.ExceptionFailure)
 182                                                   catchHandler_amaV)
 183                                                  Data.Map.Internal.Tip)
 184                                                 Data.Map.Internal.Tip)))
 185                                   inp_amb4)
 186                                  (((((Data.Map.Internal.Bin 1) SP.ExceptionFailure)
 187                                       catchHandler_amaV)
 188                                      Data.Map.Internal.Tip)
 189                                     Data.Map.Internal.Tip) in
 190                     let readFail_ambe = catchHandler_amaV
 191                     in
 192                       if readMore_amab inp_amaT then
 193                           let !(# c_ambf, cs_ambg #) = readNext_amac inp_amaT
 194                           in
 195                             if (\ x_ambh -> GHC.Types.True) c_ambf then
 196                                 if (60 GHC.Classes.== c_ambf) then
 197                                     let _ = "choicesBranch.then" in
 198                                     let readFail_ambi = readFail_ambe
 199                                     in
 200                                       if readMore_amab inp_amaT then
 201                                           let !(# c_ambj, cs_ambk #) = readNext_amac inp_amaT
 202                                           in
 203                                             if (\ x_ambl -> GHC.Types.True) c_ambj then
 204                                                 let _ = "resume"
 205                                                 in
 206                                                   (((join_1s init_amaa) Data.Set.Internal.empty)
 207                                                      (let _ = "resume.genCode"
 208                                                       in Parsers.Brainfuck.Types.Backward))
 209                                                     cs_ambk
 210                                             else
 211                                                 let _ = "checkToken.else" in
 212                                                 let
 213                                                   failExp_ambm
 214                                                     = (((Data.Set.Internal.Bin 1)
 215                                                           (SP.SomeFailure
 216                                                              (case inputToken of {
 217                                                                 (Data.Proxy.Proxy :: Data.Proxy.Proxy tok'_aLiK)
 218                                                                   -> SP.FailureAny @tok'_aLiK })))
 219                                                          Data.Set.Internal.Tip)
 220                                                         Data.Set.Internal.Tip in
 221                                                 let
 222                                                   (# farInp_ambn, farExp_ambo #)
 223                                                     = case
 224                                                           ((GHC.Classes.compare @GHC.Types.Int)
 225                                                              init_amaa)
 226                                                             inp_amaT
 227                                                       of
 228                                                         GHC.Types.LT -> (# inp_amaT, failExp_ambm #)
 229                                                         GHC.Types.EQ
 230                                                           -> (# init_amaa,
 231                                                                 (failExp_ambm
 232                                                                    GHC.Base.<>
 233                                                                      Data.Set.Internal.empty) #)
 234                                                         GHC.Types.GT
 235                                                           -> (# init_amaa,
 236                                                                 Data.Set.Internal.empty #)
 237                                                 in
 238                                                   (((readFail_ambi SP.ExceptionFailure) inp_amaT)
 239                                                      farInp_ambn)
 240                                                     farExp_ambo
 241                                       else
 242                                           let _ = "checkHorizon.else" in
 243                                           let
 244                                             failExp_ambp
 245                                               = (((Data.Set.Internal.Bin 1)
 246                                                     (SP.SomeFailure
 247                                                        (case inputToken of {
 248                                                           (Data.Proxy.Proxy :: Data.Proxy.Proxy tok'_aLiK)
 249                                                             -> (SP.FailureHorizon @tok'_aLiK) 1 })))
 250                                                    Data.Set.Internal.Tip)
 251                                                   Data.Set.Internal.Tip in
 252                                           let
 253                                             (# farInp_ambq, farExp_ambr #)
 254                                               = case
 255                                                     ((GHC.Classes.compare @GHC.Types.Int) init_amaa)
 256                                                       inp_amaT
 257                                                 of
 258                                                   GHC.Types.LT -> (# inp_amaT, failExp_ambp #)
 259                                                   GHC.Types.EQ
 260                                                     -> (# init_amaa,
 261                                                           (failExp_ambp
 262                                                              GHC.Base.<> Data.Set.Internal.empty) #)
 263                                                   GHC.Types.GT
 264                                                     -> (# init_amaa, Data.Set.Internal.empty #)
 265                                           in
 266                                             (((readFail_ambi SP.ExceptionFailure) inp_amaT)
 267                                                farInp_ambq)
 268                                               farExp_ambr
 269                                 else
 270                                     let _ = "choicesBranch.else"
 271                                     in
 272                                       if (62 GHC.Classes.== c_ambf) then
 273                                           let _ = "choicesBranch.then" in
 274                                           let readFail_ambs = readFail_ambe
 275                                           in
 276                                             if readMore_amab inp_amaT then
 277                                                 let !(# c_ambt, cs_ambu #) = readNext_amac inp_amaT
 278                                                 in
 279                                                   if (\ x_ambv -> GHC.Types.True) c_ambt then
 280                                                       let _ = "resume"
 281                                                       in
 282                                                         (((join_1s init_amaa)
 283                                                             Data.Set.Internal.empty)
 284                                                            (let _ = "resume.genCode"
 285                                                             in Parsers.Brainfuck.Types.Forward))
 286                                                           cs_ambu
 287                                                   else
 288                                                       let _ = "checkToken.else" in
 289                                                       let
 290                                                         failExp_ambw
 291                                                           = (((Data.Set.Internal.Bin 1)
 292                                                                 (SP.SomeFailure
 293                                                                    (case inputToken of {
 294                                                                       (Data.Proxy.Proxy :: Data.Proxy.Proxy tok'_aLiK)
 295                                                                         -> SP.FailureAny
 296                                                                              @tok'_aLiK })))
 297                                                                Data.Set.Internal.Tip)
 298                                                               Data.Set.Internal.Tip in
 299                                                       let
 300                                                         (# farInp_ambx, farExp_amby #)
 301                                                           = case
 302                                                                 ((GHC.Classes.compare
 303                                                                     @GHC.Types.Int)
 304                                                                    init_amaa)
 305                                                                   inp_amaT
 306                                                             of
 307                                                               GHC.Types.LT
 308                                                                 -> (# inp_amaT, failExp_ambw #)
 309                                                               GHC.Types.EQ
 310                                                                 -> (# init_amaa,
 311                                                                       (failExp_ambw
 312                                                                          GHC.Base.<>
 313                                                                            Data.Set.Internal.empty) #)
 314                                                               GHC.Types.GT
 315                                                                 -> (# init_amaa,
 316                                                                       Data.Set.Internal.empty #)
 317                                                       in
 318                                                         (((readFail_ambs SP.ExceptionFailure)
 319                                                             inp_amaT)
 320                                                            farInp_ambx)
 321                                                           farExp_amby
 322                                             else
 323                                                 let _ = "checkHorizon.else" in
 324                                                 let
 325                                                   failExp_ambz
 326                                                     = (((Data.Set.Internal.Bin 1)
 327                                                           (SP.SomeFailure
 328                                                              (case inputToken of {
 329                                                                 (Data.Proxy.Proxy :: Data.Proxy.Proxy tok'_aLiK)
 330                                                                   -> (SP.FailureHorizon @tok'_aLiK)
 331                                                                        1 })))
 332                                                          Data.Set.Internal.Tip)
 333                                                         Data.Set.Internal.Tip in
 334                                                 let
 335                                                   (# farInp_ambA, farExp_ambB #)
 336                                                     = case
 337                                                           ((GHC.Classes.compare @GHC.Types.Int)
 338                                                              init_amaa)
 339                                                             inp_amaT
 340                                                       of
 341                                                         GHC.Types.LT -> (# inp_amaT, failExp_ambz #)
 342                                                         GHC.Types.EQ
 343                                                           -> (# init_amaa,
 344                                                                 (failExp_ambz
 345                                                                    GHC.Base.<>
 346                                                                      Data.Set.Internal.empty) #)
 347                                                         GHC.Types.GT
 348                                                           -> (# init_amaa,
 349                                                                 Data.Set.Internal.empty #)
 350                                                 in
 351                                                   (((readFail_ambs SP.ExceptionFailure) inp_amaT)
 352                                                      farInp_ambA)
 353                                                     farExp_ambB
 354                                       else
 355                                           let _ = "choicesBranch.else"
 356                                           in
 357                                             if (43 GHC.Classes.== c_ambf) then
 358                                                 let _ = "choicesBranch.then" in
 359                                                 let readFail_ambC = readFail_ambe
 360                                                 in
 361                                                   if readMore_amab inp_amaT then
 362                                                       let
 363                                                         !(# c_ambD, cs_ambE #)
 364                                                           = readNext_amac inp_amaT
 365                                                       in
 366                                                         if (\ x_ambF -> GHC.Types.True) c_ambD then
 367                                                             let _ = "resume"
 368                                                             in
 369                                                               (((join_1s init_amaa)
 370                                                                   Data.Set.Internal.empty)
 371                                                                  (let _ = "resume.genCode"
 372                                                                   in
 373                                                                     Parsers.Brainfuck.Types.Increment))
 374                                                                 cs_ambE
 375                                                         else
 376                                                             let _ = "checkToken.else" in
 377                                                             let
 378                                                               failExp_ambG
 379                                                                 = (((Data.Set.Internal.Bin 1)
 380                                                                       (SP.SomeFailure
 381                                                                          (case inputToken of {
 382                                                                             (Data.Proxy.Proxy :: Data.Proxy.Proxy tok'_aLiK)
 383                                                                               -> SP.FailureAny
 384                                                                                    @tok'_aLiK })))
 385                                                                      Data.Set.Internal.Tip)
 386                                                                     Data.Set.Internal.Tip in
 387                                                             let
 388                                                               (# farInp_ambH, farExp_ambI #)
 389                                                                 = case
 390                                                                       ((GHC.Classes.compare
 391                                                                           @GHC.Types.Int)
 392                                                                          init_amaa)
 393                                                                         inp_amaT
 394                                                                   of
 395                                                                     GHC.Types.LT
 396                                                                       -> (# inp_amaT,
 397                                                                             failExp_ambG #)
 398                                                                     GHC.Types.EQ
 399                                                                       -> (# init_amaa,
 400                                                                             (failExp_ambG
 401                                                                                GHC.Base.<>
 402                                                                                  Data.Set.Internal.empty) #)
 403                                                                     GHC.Types.GT
 404                                                                       -> (# init_amaa,
 405                                                                             Data.Set.Internal.empty #)
 406                                                             in
 407                                                               (((readFail_ambC SP.ExceptionFailure)
 408                                                                   inp_amaT)
 409                                                                  farInp_ambH)
 410                                                                 farExp_ambI
 411                                                   else
 412                                                       let _ = "checkHorizon.else" in
 413                                                       let
 414                                                         failExp_ambJ
 415                                                           = (((Data.Set.Internal.Bin 1)
 416                                                                 (SP.SomeFailure
 417                                                                    (case inputToken of {
 418                                                                       (Data.Proxy.Proxy :: Data.Proxy.Proxy tok'_aLiK)
 419                                                                         -> (SP.FailureHorizon
 420                                                                               @tok'_aLiK)
 421                                                                              1 })))
 422                                                                Data.Set.Internal.Tip)
 423                                                               Data.Set.Internal.Tip in
 424                                                       let
 425                                                         (# farInp_ambK, farExp_ambL #)
 426                                                           = case
 427                                                                 ((GHC.Classes.compare
 428                                                                     @GHC.Types.Int)
 429                                                                    init_amaa)
 430                                                                   inp_amaT
 431                                                             of
 432                                                               GHC.Types.LT
 433                                                                 -> (# inp_amaT, failExp_ambJ #)
 434                                                               GHC.Types.EQ
 435                                                                 -> (# init_amaa,
 436                                                                       (failExp_ambJ
 437                                                                          GHC.Base.<>
 438                                                                            Data.Set.Internal.empty) #)
 439                                                               GHC.Types.GT
 440                                                                 -> (# init_amaa,
 441                                                                       Data.Set.Internal.empty #)
 442                                                       in
 443                                                         (((readFail_ambC SP.ExceptionFailure)
 444                                                             inp_amaT)
 445                                                            farInp_ambK)
 446                                                           farExp_ambL
 447                                             else
 448                                                 let _ = "choicesBranch.else"
 449                                                 in
 450                                                   if (45 GHC.Classes.== c_ambf) then
 451                                                       let _ = "choicesBranch.then" in
 452                                                       let readFail_ambM = readFail_ambe
 453                                                       in
 454                                                         if readMore_amab inp_amaT then
 455                                                             let
 456                                                               !(# c_ambN, cs_ambO #)
 457                                                                 = readNext_amac inp_amaT
 458                                                             in
 459                                                               if (\ x_ambP -> GHC.Types.True)
 460                                                                    c_ambN then
 461                                                                   let _ = "resume"
 462                                                                   in
 463                                                                     (((join_1s init_amaa)
 464                                                                         Data.Set.Internal.empty)
 465                                                                        (let _ = "resume.genCode"
 466                                                                         in
 467                                                                           Parsers.Brainfuck.Types.Decrement))
 468                                                                       cs_ambO
 469                                                               else
 470                                                                   let _ = "checkToken.else" in
 471                                                                   let
 472                                                                     failExp_ambQ
 473                                                                       = (((Data.Set.Internal.Bin 1)
 474                                                                             (SP.SomeFailure
 475                                                                                (case inputToken of {
 476                                                                                   (Data.Proxy.Proxy :: Data.Proxy.Proxy tok'_aLiK)
 477                                                                                     -> SP.FailureAny
 478                                                                                          @tok'_aLiK })))
 479                                                                            Data.Set.Internal.Tip)
 480                                                                           Data.Set.Internal.Tip in
 481                                                                   let
 482                                                                     (# farInp_ambR, farExp_ambS #)
 483                                                                       = case
 484                                                                             ((GHC.Classes.compare
 485                                                                                 @GHC.Types.Int)
 486                                                                                init_amaa)
 487                                                                               inp_amaT
 488                                                                         of
 489                                                                           GHC.Types.LT
 490                                                                             -> (# inp_amaT,
 491                                                                                   failExp_ambQ #)
 492                                                                           GHC.Types.EQ
 493                                                                             -> (# init_amaa,
 494                                                                                   (failExp_ambQ
 495                                                                                      GHC.Base.<>
 496                                                                                        Data.Set.Internal.empty) #)
 497                                                                           GHC.Types.GT
 498                                                                             -> (# init_amaa,
 499                                                                                   Data.Set.Internal.empty #)
 500                                                                   in
 501                                                                     (((readFail_ambM
 502                                                                          SP.ExceptionFailure)
 503                                                                         inp_amaT)
 504                                                                        farInp_ambR)
 505                                                                       farExp_ambS
 506                                                         else
 507                                                             let _ = "checkHorizon.else" in
 508                                                             let
 509                                                               failExp_ambT
 510                                                                 = (((Data.Set.Internal.Bin 1)
 511                                                                       (SP.SomeFailure
 512                                                                          (case inputToken of {
 513                                                                             (Data.Proxy.Proxy :: Data.Proxy.Proxy tok'_aLiK)
 514                                                                               -> (SP.FailureHorizon
 515                                                                                     @tok'_aLiK)
 516                                                                                    1 })))
 517                                                                      Data.Set.Internal.Tip)
 518                                                                     Data.Set.Internal.Tip in
 519                                                             let
 520                                                               (# farInp_ambU, farExp_ambV #)
 521                                                                 = case
 522                                                                       ((GHC.Classes.compare
 523                                                                           @GHC.Types.Int)
 524                                                                          init_amaa)
 525                                                                         inp_amaT
 526                                                                   of
 527                                                                     GHC.Types.LT
 528                                                                       -> (# inp_amaT,
 529                                                                             failExp_ambT #)
 530                                                                     GHC.Types.EQ
 531                                                                       -> (# init_amaa,
 532                                                                             (failExp_ambT
 533                                                                                GHC.Base.<>
 534                                                                                  Data.Set.Internal.empty) #)
 535                                                                     GHC.Types.GT
 536                                                                       -> (# init_amaa,
 537                                                                             Data.Set.Internal.empty #)
 538                                                             in
 539                                                               (((readFail_ambM SP.ExceptionFailure)
 540                                                                   inp_amaT)
 541                                                                  farInp_ambU)
 542                                                                 farExp_ambV
 543                                                   else
 544                                                       let _ = "choicesBranch.else"
 545                                                       in
 546                                                         if (44 GHC.Classes.== c_ambf) then
 547                                                             let _ = "choicesBranch.then" in
 548                                                             let readFail_ambW = readFail_ambe
 549                                                             in
 550                                                               if readMore_amab inp_amaT then
 551                                                                   let
 552                                                                     !(# c_ambX, cs_ambY #)
 553                                                                       = readNext_amac inp_amaT
 554                                                                   in
 555                                                                     if (\ x_ambZ -> GHC.Types.True)
 556                                                                          c_ambX then
 557                                                                         let _ = "resume"
 558                                                                         in
 559                                                                           (((join_1s init_amaa)
 560                                                                               Data.Set.Internal.empty)
 561                                                                              (let
 562                                                                                 _ = "resume.genCode"
 563                                                                               in
 564                                                                                 Parsers.Brainfuck.Types.Input))
 565                                                                             cs_ambY
 566                                                                     else
 567                                                                         let _ = "checkToken.else" in
 568                                                                         let
 569                                                                           failExp_amc0
 570                                                                             = (((Data.Set.Internal.Bin
 571                                                                                    1)
 572                                                                                   (SP.SomeFailure
 573                                                                                      (case
 574                                                                                           inputToken
 575                                                                                       of {
 576                                                                                         (Data.Proxy.Proxy :: Data.Proxy.Proxy tok'_aLiK)
 577                                                                                           -> SP.FailureAny
 578                                                                                                @tok'_aLiK })))
 579                                                                                  Data.Set.Internal.Tip)
 580                                                                                 Data.Set.Internal.Tip in
 581                                                                         let
 582                                                                           (# farInp_amc1,
 583                                                                              farExp_amc2 #)
 584                                                                             = case
 585                                                                                   ((GHC.Classes.compare
 586                                                                                       @GHC.Types.Int)
 587                                                                                      init_amaa)
 588                                                                                     inp_amaT
 589                                                                               of
 590                                                                                 GHC.Types.LT
 591                                                                                   -> (# inp_amaT,
 592                                                                                         failExp_amc0 #)
 593                                                                                 GHC.Types.EQ
 594                                                                                   -> (# init_amaa,
 595                                                                                         (failExp_amc0
 596                                                                                            GHC.Base.<>
 597                                                                                              Data.Set.Internal.empty) #)
 598                                                                                 GHC.Types.GT
 599                                                                                   -> (# init_amaa,
 600                                                                                         Data.Set.Internal.empty #)
 601                                                                         in
 602                                                                           (((readFail_ambW
 603                                                                                SP.ExceptionFailure)
 604                                                                               inp_amaT)
 605                                                                              farInp_amc1)
 606                                                                             farExp_amc2
 607                                                               else
 608                                                                   let _ = "checkHorizon.else" in
 609                                                                   let
 610                                                                     failExp_amc3
 611                                                                       = (((Data.Set.Internal.Bin 1)
 612                                                                             (SP.SomeFailure
 613                                                                                (case inputToken of {
 614                                                                                   (Data.Proxy.Proxy :: Data.Proxy.Proxy tok'_aLiK)
 615                                                                                     -> (SP.FailureHorizon
 616                                                                                           @tok'_aLiK)
 617                                                                                          1 })))
 618                                                                            Data.Set.Internal.Tip)
 619                                                                           Data.Set.Internal.Tip in
 620                                                                   let
 621                                                                     (# farInp_amc4, farExp_amc5 #)
 622                                                                       = case
 623                                                                             ((GHC.Classes.compare
 624                                                                                 @GHC.Types.Int)
 625                                                                                init_amaa)
 626                                                                               inp_amaT
 627                                                                         of
 628                                                                           GHC.Types.LT
 629                                                                             -> (# inp_amaT,
 630                                                                                   failExp_amc3 #)
 631                                                                           GHC.Types.EQ
 632                                                                             -> (# init_amaa,
 633                                                                                   (failExp_amc3
 634                                                                                      GHC.Base.<>
 635                                                                                        Data.Set.Internal.empty) #)
 636                                                                           GHC.Types.GT
 637                                                                             -> (# init_amaa,
 638                                                                                   Data.Set.Internal.empty #)
 639                                                                   in
 640                                                                     (((readFail_ambW
 641                                                                          SP.ExceptionFailure)
 642                                                                         inp_amaT)
 643                                                                        farInp_amc4)
 644                                                                       farExp_amc5
 645                                                         else
 646                                                             let _ = "choicesBranch.else"
 647                                                             in
 648                                                               if (46 GHC.Classes.== c_ambf) then
 649                                                                   let _ = "choicesBranch.then" in
 650                                                                   let readFail_amc6 = readFail_ambe
 651                                                                   in
 652                                                                     if readMore_amab inp_amaT then
 653                                                                         let
 654                                                                           !(# c_amc7, cs_amc8 #)
 655                                                                             = readNext_amac inp_amaT
 656                                                                         in
 657                                                                           if (\ x_amc9
 658                                                                                 -> GHC.Types.True)
 659                                                                                c_amc7 then
 660                                                                               let _ = "resume"
 661                                                                               in
 662                                                                                 (((join_1s
 663                                                                                      init_amaa)
 664                                                                                     Data.Set.Internal.empty)
 665                                                                                    (let
 666                                                                                       _ = "resume.genCode"
 667                                                                                     in
 668                                                                                       Parsers.Brainfuck.Types.Output))
 669                                                                                   cs_amc8
 670                                                                           else
 671                                                                               let
 672                                                                                 _ = "checkToken.else" in
 673                                                                               let
 674                                                                                 failExp_amca
 675                                                                                   = (((Data.Set.Internal.Bin
 676                                                                                          1)
 677                                                                                         (SP.SomeFailure
 678                                                                                            (case
 679                                                                                                 inputToken
 680                                                                                             of {
 681                                                                                               (Data.Proxy.Proxy :: Data.Proxy.Proxy tok'_aLiK)
 682                                                                                                 -> SP.FailureAny
 683                                                                                                      @tok'_aLiK })))
 684                                                                                        Data.Set.Internal.Tip)
 685                                                                                       Data.Set.Internal.Tip in
 686                                                                               let
 687                                                                                 (# farInp_amcb,
 688                                                                                    farExp_amcc #)
 689                                                                                   = case
 690                                                                                         ((GHC.Classes.compare
 691                                                                                             @GHC.Types.Int)
 692                                                                                            init_amaa)
 693                                                                                           inp_amaT
 694                                                                                     of
 695                                                                                       GHC.Types.LT
 696                                                                                         -> (# inp_amaT,
 697                                                                                               failExp_amca #)
 698                                                                                       GHC.Types.EQ
 699                                                                                         -> (# init_amaa,
 700                                                                                               (failExp_amca
 701                                                                                                  GHC.Base.<>
 702                                                                                                    Data.Set.Internal.empty) #)
 703                                                                                       GHC.Types.GT
 704                                                                                         -> (# init_amaa,
 705                                                                                               Data.Set.Internal.empty #)
 706                                                                               in
 707                                                                                 (((readFail_amc6
 708                                                                                      SP.ExceptionFailure)
 709                                                                                     inp_amaT)
 710                                                                                    farInp_amcb)
 711                                                                                   farExp_amcc
 712                                                                     else
 713                                                                         let
 714                                                                           _ = "checkHorizon.else" in
 715                                                                         let
 716                                                                           failExp_amcd
 717                                                                             = (((Data.Set.Internal.Bin
 718                                                                                    1)
 719                                                                                   (SP.SomeFailure
 720                                                                                      (case
 721                                                                                           inputToken
 722                                                                                       of {
 723                                                                                         (Data.Proxy.Proxy :: Data.Proxy.Proxy tok'_aLiK)
 724                                                                                           -> (SP.FailureHorizon
 725                                                                                                 @tok'_aLiK)
 726                                                                                                1 })))
 727                                                                                  Data.Set.Internal.Tip)
 728                                                                                 Data.Set.Internal.Tip in
 729                                                                         let
 730                                                                           (# farInp_amce,
 731                                                                              farExp_amcf #)
 732                                                                             = case
 733                                                                                   ((GHC.Classes.compare
 734                                                                                       @GHC.Types.Int)
 735                                                                                      init_amaa)
 736                                                                                     inp_amaT
 737                                                                               of
 738                                                                                 GHC.Types.LT
 739                                                                                   -> (# inp_amaT,
 740                                                                                         failExp_amcd #)
 741                                                                                 GHC.Types.EQ
 742                                                                                   -> (# init_amaa,
 743                                                                                         (failExp_amcd
 744                                                                                            GHC.Base.<>
 745                                                                                              Data.Set.Internal.empty) #)
 746                                                                                 GHC.Types.GT
 747                                                                                   -> (# init_amaa,
 748                                                                                         Data.Set.Internal.empty #)
 749                                                                         in
 750                                                                           (((readFail_amc6
 751                                                                                SP.ExceptionFailure)
 752                                                                               inp_amaT)
 753                                                                              farInp_amce)
 754                                                                             farExp_amcf
 755                                                               else
 756                                                                   let _ = "choicesBranch.else"
 757                                                                   in
 758                                                                     if (91
 759                                                                           GHC.Classes.==
 760                                                                             c_ambf) then
 761                                                                         let
 762                                                                           _ = "choicesBranch.then" in
 763                                                                         let
 764                                                                           readFail_amcg
 765                                                                             = readFail_ambe
 766                                                                         in
 767                                                                           if readMore_amab
 768                                                                                ((((GHC.Num.+)
 769                                                                                     @GHC.Types.Int)
 770                                                                                    1)
 771                                                                                   inp_amaT) then
 772                                                                               let
 773                                                                                 !(# c_amch,
 774                                                                                     cs_amci #)
 775                                                                                   = readNext_amac
 776                                                                                       inp_amaT
 777                                                                               in
 778                                                                                 if (\ x_amcj
 779                                                                                       -> GHC.Types.True)
 780                                                                                      c_amch then
 781                                                                                     ((name_1
 782                                                                                         (let
 783                                                                                            _ = "suspend"
 784                                                                                          in
 785                                                                                            \ farInp_amck
 786                                                                                              farExp_amcl
 787                                                                                              v_amcm
 788                                                                                              !inp_amcn
 789                                                                                              -> ((name_2
 790                                                                                                     (let
 791                                                                                                        _ = "suspend"
 792                                                                                                      in
 793                                                                                                        \ farInp_amco
 794                                                                                                          farExp_amcp
 795                                                                                                          v_amcq
 796                                                                                                          !inp_amcr
 797                                                                                                          -> let
 798                                                                                                               readFail_amcs
 799                                                                                                                 = readFail_amcg
 800                                                                                                             in
 801                                                                                                               if readMore_amab
 802                                                                                                                    inp_amcr then
 803                                                                                                                   let
 804                                                                                                                     !(# c_amct,
 805                                                                                                                         cs_amcu #)
 806                                                                                                                       = readNext_amac
 807                                                                                                                           inp_amcr
 808                                                                                                                   in
 809                                                                                                                     if (93
 810                                                                                                                         GHC.Classes.==)
 811                                                                                                                          c_amct then
 812                                                                                                                         let
 813                                                                                                                           _ = "resume"
 814                                                                                                                         in
 815                                                                                                                           (((join_1s
 816                                                                                                                                farInp_amco)
 817                                                                                                                               farExp_amcp)
 818                                                                                                                              (let
 819                                                                                                                                 _ = "resume.genCode"
 820                                                                                                                               in
 821                                                                                                                                 Parsers.Brainfuck.Types.Loop
 822                                                                                                                                   v_amcq))
 823                                                                                                                             cs_amcu
 824                                                                                                                     else
 825                                                                                                                         let
 826                                                                                                                           _ = "checkToken.else"
 827                                                                                                                         in
 828                                                                                                                           (((readFail_amcs
 829                                                                                                                                SP.ExceptionFailure)
 830                                                                                                                               inp_amcr)
 831                                                                                                                              farInp_amco)
 832                                                                                                                             farExp_amcp
 833                                                                                                               else
 834                                                                                                                   let
 835                                                                                                                     _ = "checkHorizon.else" in
 836                                                                                                                   let
 837                                                                                                                     failExp_amcv
 838                                                                                                                       = (((Data.Set.Internal.Bin
 839                                                                                                                              1)
 840                                                                                                                             (SP.SomeFailure
 841                                                                                                                                (case
 842                                                                                                                                     inputToken
 843                                                                                                                                 of {
 844                                                                                                                                   (Data.Proxy.Proxy :: Data.Proxy.Proxy tok'_aLiK)
 845                                                                                                                                     -> (SP.FailureHorizon
 846                                                                                                                                           @tok'_aLiK)
 847                                                                                                                                          1 })))
 848                                                                                                                            Data.Set.Internal.Tip)
 849                                                                                                                           Data.Set.Internal.Tip in
 850                                                                                                                   let
 851                                                                                                                     (# farInp_amcw,
 852                                                                                                                        farExp_amcx #)
 853                                                                                                                       = case
 854                                                                                                                             ((GHC.Classes.compare
 855                                                                                                                                 @GHC.Types.Int)
 856                                                                                                                                farInp_amco)
 857                                                                                                                               inp_amcr
 858                                                                                                                         of
 859                                                                                                                           GHC.Types.LT
 860                                                                                                                             -> (# inp_amcr,
 861                                                                                                                                   failExp_amcv #)
 862                                                                                                                           GHC.Types.EQ
 863                                                                                                                             -> (# farInp_amco,
 864                                                                                                                                   (failExp_amcv
 865                                                                                                                                      GHC.Base.<>
 866                                                                                                                                        farExp_amcp) #)
 867                                                                                                                           GHC.Types.GT
 868                                                                                                                             -> (# farInp_amco,
 869                                                                                                                                   farExp_amcp #)
 870                                                                                                                   in
 871                                                                                                                     (((readFail_amcs
 872                                                                                                                          SP.ExceptionFailure)
 873                                                                                                                         inp_amcr)
 874                                                                                                                        farInp_amcw)
 875                                                                                                                       farExp_amcx))
 876                                                                                                    inp_amcn)
 877                                                                                                   (((((Data.Map.Internal.Bin
 878                                                                                                          1)
 879                                                                                                         SP.ExceptionFailure)
 880                                                                                                        readFail_amcg)
 881                                                                                                       Data.Map.Internal.Tip)
 882                                                                                                      Data.Map.Internal.Tip)))
 883                                                                                        cs_amci)
 884                                                                                       (((((Data.Map.Internal.Bin
 885                                                                                              1)
 886                                                                                             SP.ExceptionFailure)
 887                                                                                            readFail_amcg)
 888                                                                                           Data.Map.Internal.Tip)
 889                                                                                          Data.Map.Internal.Tip)
 890                                                                                 else
 891                                                                                     let
 892                                                                                       _ = "checkToken.else" in
 893                                                                                     let
 894                                                                                       failExp_amcy
 895                                                                                         = (((Data.Set.Internal.Bin
 896                                                                                                1)
 897                                                                                               (SP.SomeFailure
 898                                                                                                  (case
 899                                                                                                       inputToken
 900                                                                                                   of {
 901                                                                                                     (Data.Proxy.Proxy :: Data.Proxy.Proxy tok'_aLiK)
 902                                                                                                       -> SP.FailureAny
 903                                                                                                            @tok'_aLiK })))
 904                                                                                              Data.Set.Internal.Tip)
 905                                                                                             Data.Set.Internal.Tip in
 906                                                                                     let
 907                                                                                       (# farInp_amcz,
 908                                                                                          farExp_amcA #)
 909                                                                                         = case
 910                                                                                               ((GHC.Classes.compare
 911                                                                                                   @GHC.Types.Int)
 912                                                                                                  init_amaa)
 913                                                                                                 inp_amaT
 914                                                                                           of
 915                                                                                             GHC.Types.LT
 916                                                                                               -> (# inp_amaT,
 917                                                                                                     failExp_amcy #)
 918                                                                                             GHC.Types.EQ
 919                                                                                               -> (# init_amaa,
 920                                                                                                     (failExp_amcy
 921                                                                                                        GHC.Base.<>
 922                                                                                                          Data.Set.Internal.empty) #)
 923                                                                                             GHC.Types.GT
 924                                                                                               -> (# init_amaa,
 925                                                                                                     Data.Set.Internal.empty #)
 926                                                                                     in
 927                                                                                       (((readFail_amcg
 928                                                                                            SP.ExceptionFailure)
 929                                                                                           inp_amaT)
 930                                                                                          farInp_amcz)
 931                                                                                         farExp_amcA
 932                                                                           else
 933                                                                               let
 934                                                                                 _ = "checkHorizon.else" in
 935                                                                               let
 936                                                                                 failExp_amcB
 937                                                                                   = (((Data.Set.Internal.Bin
 938                                                                                          1)
 939                                                                                         (SP.SomeFailure
 940                                                                                            (case
 941                                                                                                 inputToken
 942                                                                                             of {
 943                                                                                               (Data.Proxy.Proxy :: Data.Proxy.Proxy tok'_aLiK)
 944                                                                                                 -> (SP.FailureHorizon
 945                                                                                                       @tok'_aLiK)
 946                                                                                                      2 })))
 947                                                                                        Data.Set.Internal.Tip)
 948                                                                                       Data.Set.Internal.Tip in
 949                                                                               let
 950                                                                                 (# farInp_amcC,
 951                                                                                    farExp_amcD #)
 952                                                                                   = case
 953                                                                                         ((GHC.Classes.compare
 954                                                                                             @GHC.Types.Int)
 955                                                                                            init_amaa)
 956                                                                                           inp_amaT
 957                                                                                     of
 958                                                                                       GHC.Types.LT
 959                                                                                         -> (# inp_amaT,
 960                                                                                               failExp_amcB #)
 961                                                                                       GHC.Types.EQ
 962                                                                                         -> (# init_amaa,
 963                                                                                               (failExp_amcB
 964                                                                                                  GHC.Base.<>
 965                                                                                                    Data.Set.Internal.empty) #)
 966                                                                                       GHC.Types.GT
 967                                                                                         -> (# init_amaa,
 968                                                                                               Data.Set.Internal.empty #)
 969                                                                               in
 970                                                                                 (((readFail_amcg
 971                                                                                      SP.ExceptionFailure)
 972                                                                                     inp_amaT)
 973                                                                                    farInp_amcC)
 974                                                                                   farExp_amcD
 975                                                                     else
 976                                                                         let
 977                                                                           _ = "choicesBranch.else" in
 978                                                                         let
 979                                                                           failExp_amcE
 980                                                                             = (((Data.Set.Internal.Bin
 981                                                                                    1)
 982                                                                                   (SP.SomeFailure
 983                                                                                      SP.FailureEmpty))
 984                                                                                  Data.Set.Internal.Tip)
 985                                                                                 Data.Set.Internal.Tip in
 986                                                                         let
 987                                                                           (# farInp_amcF,
 988                                                                              farExp_amcG #)
 989                                                                             = case
 990                                                                                   ((GHC.Classes.compare
 991                                                                                       @GHC.Types.Int)
 992                                                                                      init_amaa)
 993                                                                                     inp_amaT
 994                                                                               of
 995                                                                                 GHC.Types.LT
 996                                                                                   -> (# inp_amaT,
 997                                                                                         failExp_amcE #)
 998                                                                                 GHC.Types.EQ
 999                                                                                   -> (# init_amaa,
1000                                                                                         (failExp_amcE
1001                                                                                            GHC.Base.<>
1002                                                                                              Data.Set.Internal.empty) #)
1003                                                                                 GHC.Types.GT
1004                                                                                   -> (# init_amaa,
1005                                                                                         Data.Set.Internal.empty #)
1006                                                                         in
1007                                                                           (((readFail_ambe
1008                                                                                SP.ExceptionFailure)
1009                                                                               inp_amaT)
1010                                                                              farInp_amcF)
1011                                                                             farExp_amcG
1012                             else
1013                                 let _ = "checkToken.else" in
1014                                 let
1015                                   failExp_amcH
1016                                     = (((Data.Set.Internal.Bin 1)
1017                                           (SP.SomeFailure
1018                                              (case inputToken of {
1019                                                 (Data.Proxy.Proxy :: Data.Proxy.Proxy tok'_aLiK)
1020                                                   -> SP.FailureAny @tok'_aLiK })))
1021                                          Data.Set.Internal.Tip)
1022                                         Data.Set.Internal.Tip in
1023                                 let
1024                                   (# farInp_amcI, farExp_amcJ #)
1025                                     = case
1026                                           ((GHC.Classes.compare @GHC.Types.Int) init_amaa) inp_amaT
1027                                       of
1028                                         GHC.Types.LT -> (# inp_amaT, failExp_amcH #)
1029                                         GHC.Types.EQ
1030                                           -> (# init_amaa,
1031                                                 (failExp_amcH
1032                                                    GHC.Base.<> Data.Set.Internal.empty) #)
1033                                         GHC.Types.GT -> (# init_amaa, Data.Set.Internal.empty #)
1034                                 in
1035                                   (((readFail_ambe SP.ExceptionFailure) inp_amaT) farInp_amcI)
1036                                     farExp_amcJ
1037                       else
1038                           let _ = "checkHorizon.else" in
1039                           let
1040                             failExp_amcK
1041                               = (((Data.Set.Internal.Bin 1)
1042                                     (SP.SomeFailure
1043                                        (case inputToken of {
1044                                           (Data.Proxy.Proxy :: Data.Proxy.Proxy tok'_aLiK)
1045                                             -> (SP.FailureHorizon @tok'_aLiK) 1 })))
1046                                    Data.Set.Internal.Tip)
1047                                   Data.Set.Internal.Tip in
1048                           let
1049                             (# farInp_amcL, farExp_amcM #)
1050                               = case ((GHC.Classes.compare @GHC.Types.Int) init_amaa) inp_amaT of
1051                                   GHC.Types.LT -> (# inp_amaT, failExp_amcK #)
1052                                   GHC.Types.EQ
1053                                     -> (# init_amaa,
1054                                           (failExp_amcK GHC.Base.<> Data.Set.Internal.empty) #)
1055                                   GHC.Types.GT -> (# init_amaa, Data.Set.Internal.empty #)
1056                           in
1057                             (((readFail_ambe SP.ExceptionFailure) inp_amaT) farInp_amcL)
1058                               farExp_amcM
1059            name_4
1060              = \ !ok_amax !inp_amay !koByLabel_amaz
1061                  -> let _ = "catch ExceptionFailure" in
1062                     let
1063                       catchHandler_amaA
1064                         !_exn_amaB
1065                         !failInp_amaC
1066                         !farInp_amaD
1067                         !farExp_amaE
1068                         = let _ = "catch.ko ExceptionFailure"
1069                           in
1070                             if (((GHC.Classes.==) @GHC.Types.Int) inp_amay) failInp_amaC then
1071                                 let _ = "choicesBranch.then" in
1072                                 let _ = "resume"
1073                                 in
1074                                   (((ok_amax farInp_amaD) farExp_amaE)
1075                                      (let _ = "resume.genCode" in \ x_amaF -> x_amaF))
1076                                     failInp_amaC
1077                             else
1078                                 let _ = "choicesBranch.else"
1079                                 in
1080                                   ((((((Data.Map.Strict.Internal.findWithDefault finalRaise_amad)
1081                                          SP.ExceptionFailure)
1082                                         koByLabel_amaz)
1083                                        SP.ExceptionFailure)
1084                                       failInp_amaC)
1085                                      farInp_amaD)
1086                                     farExp_amaE in
1087                     let readFail_amaG = catchHandler_amaA
1088                     in
1089                       if readMore_amab inp_amay then
1090                           let !(# c_amaH, cs_amaI #) = readNext_amac inp_amay
1091                           in
1092                             if (\ c_amaJ
1093                                   -> GHC.Classes.not
1094                                        ((60 GHC.Classes.== c_amaJ)
1095                                           GHC.Classes.||
1096                                             ((62 GHC.Classes.== c_amaJ)
1097                                                GHC.Classes.||
1098                                                  ((43 GHC.Classes.== c_amaJ)
1099                                                     GHC.Classes.||
1100                                                       ((45 GHC.Classes.== c_amaJ)
1101                                                          GHC.Classes.||
1102                                                            ((44 GHC.Classes.== c_amaJ)
1103                                                               GHC.Classes.||
1104                                                                 ((46 GHC.Classes.== c_amaJ)
1105                                                                    GHC.Classes.||
1106                                                                      ((91 GHC.Classes.== c_amaJ)
1107                                                                         GHC.Classes.||
1108                                                                           ((93
1109                                                                               GHC.Classes.== c_amaJ)
1110                                                                              GHC.Classes.||
1111                                                                                GHC.Types.False)))))))))
1112                                  c_amaH then
1113                                 ((name_4
1114                                     (let _ = "suspend"
1115                                      in
1116                                        \ farInp_amaK farExp_amaL v_amaM !inp_amaN
1117                                          -> let _ = "resume"
1118                                             in
1119                                               (((ok_amax farInp_amaK) farExp_amaL)
1120                                                  (let _ = "resume.genCode"
1121                                                   in \ x_amaO -> v_amaM x_amaO))
1122                                                 inp_amaN))
1123                                    cs_amaI)
1124                                   (((((Data.Map.Internal.Bin 1) SP.ExceptionFailure) readFail_amaG)
1125                                       Data.Map.Internal.Tip)
1126                                      Data.Map.Internal.Tip)
1127                             else
1128                                 let _ = "checkToken.else"
1129                                 in
1130                                   (((readFail_amaG SP.ExceptionFailure) inp_amay) init_amaa)
1131                                     Data.Set.Internal.empty
1132                       else
1133                           let _ = "checkHorizon.else" in
1134                           let
1135                             failExp_amaP
1136                               = (((Data.Set.Internal.Bin 1)
1137                                     (SP.SomeFailure
1138                                        (case inputToken of {
1139                                           (Data.Proxy.Proxy :: Data.Proxy.Proxy tok'_aLiK)
1140                                             -> (SP.FailureHorizon @tok'_aLiK) 1 })))
1141                                    Data.Set.Internal.Tip)
1142                                   Data.Set.Internal.Tip in
1143                           let
1144                             (# farInp_amaQ, farExp_amaR #)
1145                               = case ((GHC.Classes.compare @GHC.Types.Int) init_amaa) inp_amay of
1146                                   GHC.Types.LT -> (# inp_amay, failExp_amaP #)
1147                                   GHC.Types.EQ
1148                                     -> (# init_amaa,
1149                                           (failExp_amaP GHC.Base.<> Data.Set.Internal.empty) #)
1150                                   GHC.Types.GT -> (# init_amaa, Data.Set.Internal.empty #)
1151                           in
1152                             (((readFail_amaG SP.ExceptionFailure) inp_amay) farInp_amaQ)
1153                               farExp_amaR
1154          in
1155            ((name_1
1156                (let _ = "suspend"
1157                 in
1158                   \ farInp_amd1 farExp_amd2 v_amd3 !inp_amd4
1159                     -> ((name_2
1160                            (let _ = "suspend"
1161                             in
1162                               \ farInp_amd5 farExp_amd6 v_amd7 !inp_amd8
1163                                 -> let _ = "resume"
1164                                    in
1165                                      (((finalRet_ama9 farInp_amd5) farExp_amd6)
1166                                         (let _ = "resume.genCode" in v_amd7))
1167                                        inp_amd8))
1168                           inp_amd4)
1169                          Data.Map.Internal.Tip))
1170               init_amaa)
1171              Data.Map.Internal.Tip