tests/Golden/Machine/G13.expected.txt

   1 let name
   2   minReads=0
   3   mayRaise=[ExceptionFailure]
   4   alwaysRaise=[]
   5   freeRegs=[]
   6 | pushValue (\x_0 -> GHC.Tuple.())
   7 |   minReads=0
   8 |   mayRaise=[ExceptionFailure]
   9 |   alwaysRaise=[]
  10 |   freeRegs=[]
  11 | pushValue (\x_0 -> x_0)
  12 |   minReads=0
  13 |   mayRaise=[ExceptionFailure]
  14 |   alwaysRaise=[]
  15 |   freeRegs=[]
  16 | newRegister reg
  17 |   minReads=0
  18 |   mayRaise=[ExceptionFailure]
  19 |   alwaysRaise=[]
  20 |   freeRegs=[]
  21 | iter loop
  22 |   minReads=0
  23 |   mayRaise=[ExceptionFailure]
  24 |   alwaysRaise=[]
  25 |   freeRegs=[reg]
  26 | | <ok>
  27 | | | pushValue (\x_0 -> \x_1 -> x_1)
  28 | | |   minReads=1
  29 | | |   mayRaise=[ExceptionFailure]
  30 | | |   alwaysRaise=[]
  31 | | |   freeRegs=[reg]
  32 | | | comment "satisfy (\\c_0 -> GHC.Classes.not (('<' GHC.Classes.== c_0) GHC.Classes.|| (('>' GHC.Classes.== c_0) GHC.Classes.|| (('+' GHC.Classes.== c_0) GHC.Classes.|| (('-' GHC.Classes.== c_0) GHC.Classes.|| ((',' GHC.Classes.== c_0) GHC.Classes.|| (('.' GHC.Classes.== c_0) GHC.Classes.|| (('[' GHC.Classes.== c_0) GHC.Classes.|| ((']' GHC.Classes.== c_0) GHC.Classes.|| GHC.Types.False)))))))))"
  33 | | |   minReads=1
  34 | | |   mayRaise=[ExceptionFailure]
  35 | | |   alwaysRaise=[]
  36 | | |   freeRegs=[reg]
  37 | | | read (\c_0 -> GHC.Classes.not (('<' GHC.Classes.== c_0) GHC.Classes.|| (('>' GHC.Classes.== c_0) GHC.Classes.|| (('+' GHC.Classes.== c_0) GHC.Classes.|| (('-' GHC.Classes.== c_0) GHC.Classes.|| ((',' GHC.Classes.== c_0) GHC.Classes.|| (('.' GHC.Classes.== c_0) GHC.Classes.|| (('[' GHC.Classes.== c_0) GHC.Classes.|| ((']' GHC.Classes.== c_0) GHC.Classes.|| GHC.Types.False)))))))))
  38 | | |   minReads=1
  39 | | |   mayRaise=[ExceptionFailure]
  40 | | |   alwaysRaise=[]
  41 | | |   freeRegs=[reg]
  42 | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)
  43 | | |   minReads=0
  44 | | |   mayRaise=[]
  45 | | |   alwaysRaise=[]
  46 | | |   freeRegs=[reg]
  47 | | | readRegister reg
  48 | | |   minReads=0
  49 | | |   mayRaise=[]
  50 | | |   alwaysRaise=[]
  51 | | |   freeRegs=[reg]
  52 | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)
  53 | | |   minReads=0
  54 | | |   mayRaise=[]
  55 | | |   alwaysRaise=[]
  56 | | |   freeRegs=[reg]
  57 | | | writeRegister reg
  58 | | |   minReads=0
  59 | | |   mayRaise=[]
  60 | | |   alwaysRaise=[]
  61 | | |   freeRegs=[reg]
  62 | | | jump loop
  63 | | |   minReads=0
  64 | | |   mayRaise=[]
  65 | | |   alwaysRaise=[]
  66 | | |   freeRegs=[]
  67 | | <ko>
  68 | | | comment "raiseAgainIfConsumed"
  69 | | |   minReads=0
  70 | | |   mayRaise=[ExceptionFailure]
  71 | | |   alwaysRaise=[]
  72 | | |   freeRegs=[reg]
  73 | | | saveInput
  74 | | |   minReads=0
  75 | | |   mayRaise=[ExceptionFailure]
  76 | | |   alwaysRaise=[]
  77 | | |   freeRegs=[reg]
  78 | | | lift2Value (\(Data.Text.Internal.Text _ i_0 _) (Data.Text.Internal.Text _
  79 | | |                                                                j_1
  80 | | |                                                                _) -> i_0 GHC.Classes.== j_1)
  81 | | |   minReads=0
  82 | | |   mayRaise=[ExceptionFailure]
  83 | | |   alwaysRaise=[]
  84 | | |   freeRegs=[reg]
  85 | | | choicesBranch
  86 | | |   minReads=0
  87 | | |   mayRaise=[ExceptionFailure]
  88 | | |   alwaysRaise=[]
  89 | | |   freeRegs=[reg]
  90 | | | | <branch (\x_0 -> x_0)>
  91 | | | | | readRegister reg
  92 | | | | |   minReads=0
  93 | | | | |   mayRaise=[]
  94 | | | | |   alwaysRaise=[]
  95 | | | | |   freeRegs=[reg]
  96 | | | | | pushValue GHC.Tuple.()
  97 | | | | |   minReads=0
  98 | | | | |   mayRaise=[]
  99 | | | | |   alwaysRaise=[]
 100 | | | | |   freeRegs=[]
 101 | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)
 102 | | | | |   minReads=0
 103 | | | | |   mayRaise=[]
 104 | | | | |   alwaysRaise=[]
 105 | | | | |   freeRegs=[]
 106 | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)
 107 | | | | |   minReads=0
 108 | | | | |   mayRaise=[]
 109 | | | | |   alwaysRaise=[]
 110 | | | | |   freeRegs=[]
 111 | | | | | ret
 112 | | | | |   minReads=0
 113 | | | | |   mayRaise=[]
 114 | | | | |   alwaysRaise=[]
 115 | | | | |   freeRegs=[]
 116 | | | | <default>
 117 | | | | | fail []
 118 | | | | |   minReads=0
 119 | | | | |   mayRaise=[ExceptionFailure]
 120 | | | | |   alwaysRaise=[ExceptionFailure]
 121 | | | | |   freeRegs=[]
 122 let name
 123   minReads=0
 124   mayRaise=[ExceptionFailure]
 125   alwaysRaise=[]
 126   freeRegs=[]
 127 | pushValue (\x_0 -> x_0)
 128 |   minReads=0
 129 |   mayRaise=[ExceptionFailure]
 130 |   alwaysRaise=[]
 131 |   freeRegs=[]
 132 | newRegister reg
 133 |   minReads=0
 134 |   mayRaise=[ExceptionFailure]
 135 |   alwaysRaise=[]
 136 |   freeRegs=[]
 137 | iter loop
 138 |   minReads=0
 139 |   mayRaise=[ExceptionFailure]
 140 |   alwaysRaise=[]
 141 |   freeRegs=[reg]
 142 | | <ok>
 143 | | | pushValue (\x_0 -> \x_1 -> (GHC.Types.:) x_0)
 144 | | |   minReads=1
 145 | | |   mayRaise=[ExceptionFailure]
 146 | | |   alwaysRaise=[]
 147 | | |   freeRegs=[reg]
 148 | | | join join
 149 | | |   minReads=0
 150 | | |   mayRaise=[ExceptionFailure]
 151 | | |   alwaysRaise=[]
 152 | | |   freeRegs=[reg]
 153 | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)
 154 | | | |   minReads=0
 155 | | | |   mayRaise=[ExceptionFailure]
 156 | | | |   alwaysRaise=[]
 157 | | | |   freeRegs=[reg]
 158 | | | | call name
 159 | | | |   minReads=0
 160 | | | |   mayRaise=[ExceptionFailure]
 161 | | | |   alwaysRaise=[]
 162 | | | |   freeRegs=[reg]
 163 | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)
 164 | | | |   minReads=0
 165 | | | |   mayRaise=[]
 166 | | | |   alwaysRaise=[]
 167 | | | |   freeRegs=[reg]
 168 | | | | pushValue (\x_0 -> \x_1 -> \x_2 -> x_1 (x_0 x_2))
 169 | | | |   minReads=0
 170 | | | |   mayRaise=[]
 171 | | | |   alwaysRaise=[]
 172 | | | |   freeRegs=[reg]
 173 | | | | lift2Value (\x_0 -> \x_1 -> x_1 x_0)
 174 | | | |   minReads=0
 175 | | | |   mayRaise=[]
 176 | | | |   alwaysRaise=[]
 177 | | | |   freeRegs=[reg]
 178 | | | | readRegister reg
 179 | | | |   minReads=0
 180 | | | |   mayRaise=[]
 181 | | | |   alwaysRaise=[]
 182 | | | |   freeRegs=[reg]
 183 | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)
 184 | | | |   minReads=0
 185 | | | |   mayRaise=[]
 186 | | | |   alwaysRaise=[]
 187 | | | |   freeRegs=[reg]
 188 | | | | writeRegister reg
 189 | | | |   minReads=0
 190 | | | |   mayRaise=[]
 191 | | | |   alwaysRaise=[]
 192 | | | |   freeRegs=[reg]
 193 | | | | jump loop
 194 | | | |   minReads=0
 195 | | | |   mayRaise=[]
 196 | | | |   alwaysRaise=[]
 197 | | | |   freeRegs=[]
 198 | | | comment "look"
 199 | | |   minReads=1
 200 | | |   mayRaise=[ExceptionFailure]
 201 | | |   alwaysRaise=[]
 202 | | |   freeRegs=[reg]
 203 | | | saveInput
 204 | | |   minReads=1
 205 | | |   mayRaise=[ExceptionFailure]
 206 | | |   alwaysRaise=[]
 207 | | |   freeRegs=[reg]
 208 | | | comment "satisfy ((\\x_0 -> \\x_1 -> x_0) GHC.Types.True)"
 209 | | |   minReads=1
 210 | | |   mayRaise=[ExceptionFailure]
 211 | | |   alwaysRaise=[]
 212 | | |   freeRegs=[reg]
 213 | | | read (\x_0 -> GHC.Types.True)
 214 | | |   minReads=1
 215 | | |   mayRaise=[ExceptionFailure]
 216 | | |   alwaysRaise=[]
 217 | | |   freeRegs=[reg]
 218 | | | swapValue
 219 | | |   minReads=0
 220 | | |   mayRaise=[ExceptionFailure]
 221 | | |   alwaysRaise=[]
 222 | | |   freeRegs=[reg]
 223 | | | loadInput
 224 | | |   minReads=0
 225 | | |   mayRaise=[ExceptionFailure]
 226 | | |   alwaysRaise=[]
 227 | | |   freeRegs=[reg]
 228 | | | choicesBranch
 229 | | |   minReads=1
 230 | | |   mayRaise=[ExceptionFailure]
 231 | | |   alwaysRaise=[]
 232 | | |   freeRegs=[reg]
 233 | | | | <branch (\x_0 -> (GHC.Classes.==) '<' x_0)>
 234 | | | | | pushValue (\x_0 -> Parsers.Brainfuck.Types.Backward)
 235 | | | | |   minReads=1
 236 | | | | |   mayRaise=[ExceptionFailure]
 237 | | | | |   alwaysRaise=[]
 238 | | | | |   freeRegs=[reg]
 239 | | | | | comment "satisfy ((\\x_0 -> \\x_1 -> x_0) GHC.Types.True)"
 240 | | | | |   minReads=1
 241 | | | | |   mayRaise=[ExceptionFailure]
 242 | | | | |   alwaysRaise=[]
 243 | | | | |   freeRegs=[reg]
 244 | | | | | read (\x_0 -> GHC.Types.True)
 245 | | | | |   minReads=1
 246 | | | | |   mayRaise=[ExceptionFailure]
 247 | | | | |   alwaysRaise=[]
 248 | | | | |   freeRegs=[reg]
 249 | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)
 250 | | | | |   minReads=0
 251 | | | | |   mayRaise=[ExceptionFailure]
 252 | | | | |   alwaysRaise=[]
 253 | | | | |   freeRegs=[reg]
 254 | | | | | refJoin join
 255 | | | | |   minReads=0
 256 | | | | |   mayRaise=[ExceptionFailure]
 257 | | | | |   alwaysRaise=[]
 258 | | | | |   freeRegs=[reg]
 259 | | | | <branch (\x_0 -> (GHC.Classes.==) '>' x_0)>
 260 | | | | | pushValue (\x_0 -> Parsers.Brainfuck.Types.Forward)
 261 | | | | |   minReads=1
 262 | | | | |   mayRaise=[ExceptionFailure]
 263 | | | | |   alwaysRaise=[]
 264 | | | | |   freeRegs=[reg]
 265 | | | | | comment "satisfy ((\\x_0 -> \\x_1 -> x_0) GHC.Types.True)"
 266 | | | | |   minReads=1
 267 | | | | |   mayRaise=[ExceptionFailure]
 268 | | | | |   alwaysRaise=[]
 269 | | | | |   freeRegs=[reg]
 270 | | | | | read (\x_0 -> GHC.Types.True)
 271 | | | | |   minReads=1
 272 | | | | |   mayRaise=[ExceptionFailure]
 273 | | | | |   alwaysRaise=[]
 274 | | | | |   freeRegs=[reg]
 275 | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)
 276 | | | | |   minReads=0
 277 | | | | |   mayRaise=[ExceptionFailure]
 278 | | | | |   alwaysRaise=[]
 279 | | | | |   freeRegs=[reg]
 280 | | | | | refJoin join
 281 | | | | |   minReads=0
 282 | | | | |   mayRaise=[ExceptionFailure]
 283 | | | | |   alwaysRaise=[]
 284 | | | | |   freeRegs=[reg]
 285 | | | | <branch (\x_0 -> (GHC.Classes.==) '+' x_0)>
 286 | | | | | pushValue (\x_0 -> Parsers.Brainfuck.Types.Increment)
 287 | | | | |   minReads=1
 288 | | | | |   mayRaise=[ExceptionFailure]
 289 | | | | |   alwaysRaise=[]
 290 | | | | |   freeRegs=[reg]
 291 | | | | | comment "satisfy ((\\x_0 -> \\x_1 -> x_0) GHC.Types.True)"
 292 | | | | |   minReads=1
 293 | | | | |   mayRaise=[ExceptionFailure]
 294 | | | | |   alwaysRaise=[]
 295 | | | | |   freeRegs=[reg]
 296 | | | | | read (\x_0 -> GHC.Types.True)
 297 | | | | |   minReads=1
 298 | | | | |   mayRaise=[ExceptionFailure]
 299 | | | | |   alwaysRaise=[]
 300 | | | | |   freeRegs=[reg]
 301 | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)
 302 | | | | |   minReads=0
 303 | | | | |   mayRaise=[ExceptionFailure]
 304 | | | | |   alwaysRaise=[]
 305 | | | | |   freeRegs=[reg]
 306 | | | | | refJoin join
 307 | | | | |   minReads=0
 308 | | | | |   mayRaise=[ExceptionFailure]
 309 | | | | |   alwaysRaise=[]
 310 | | | | |   freeRegs=[reg]
 311 | | | | <branch (\x_0 -> (GHC.Classes.==) '-' x_0)>
 312 | | | | | pushValue (\x_0 -> Parsers.Brainfuck.Types.Decrement)
 313 | | | | |   minReads=1
 314 | | | | |   mayRaise=[ExceptionFailure]
 315 | | | | |   alwaysRaise=[]
 316 | | | | |   freeRegs=[reg]
 317 | | | | | comment "satisfy ((\\x_0 -> \\x_1 -> x_0) GHC.Types.True)"
 318 | | | | |   minReads=1
 319 | | | | |   mayRaise=[ExceptionFailure]
 320 | | | | |   alwaysRaise=[]
 321 | | | | |   freeRegs=[reg]
 322 | | | | | read (\x_0 -> GHC.Types.True)
 323 | | | | |   minReads=1
 324 | | | | |   mayRaise=[ExceptionFailure]
 325 | | | | |   alwaysRaise=[]
 326 | | | | |   freeRegs=[reg]
 327 | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)
 328 | | | | |   minReads=0
 329 | | | | |   mayRaise=[ExceptionFailure]
 330 | | | | |   alwaysRaise=[]
 331 | | | | |   freeRegs=[reg]
 332 | | | | | refJoin join
 333 | | | | |   minReads=0
 334 | | | | |   mayRaise=[ExceptionFailure]
 335 | | | | |   alwaysRaise=[]
 336 | | | | |   freeRegs=[reg]
 337 | | | | <branch (\x_0 -> (GHC.Classes.==) ',' x_0)>
 338 | | | | | pushValue (\x_0 -> Parsers.Brainfuck.Types.Input)
 339 | | | | |   minReads=1
 340 | | | | |   mayRaise=[ExceptionFailure]
 341 | | | | |   alwaysRaise=[]
 342 | | | | |   freeRegs=[reg]
 343 | | | | | comment "satisfy ((\\x_0 -> \\x_1 -> x_0) GHC.Types.True)"
 344 | | | | |   minReads=1
 345 | | | | |   mayRaise=[ExceptionFailure]
 346 | | | | |   alwaysRaise=[]
 347 | | | | |   freeRegs=[reg]
 348 | | | | | read (\x_0 -> GHC.Types.True)
 349 | | | | |   minReads=1
 350 | | | | |   mayRaise=[ExceptionFailure]
 351 | | | | |   alwaysRaise=[]
 352 | | | | |   freeRegs=[reg]
 353 | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)
 354 | | | | |   minReads=0
 355 | | | | |   mayRaise=[ExceptionFailure]
 356 | | | | |   alwaysRaise=[]
 357 | | | | |   freeRegs=[reg]
 358 | | | | | refJoin join
 359 | | | | |   minReads=0
 360 | | | | |   mayRaise=[ExceptionFailure]
 361 | | | | |   alwaysRaise=[]
 362 | | | | |   freeRegs=[reg]
 363 | | | | <branch (\x_0 -> (GHC.Classes.==) '.' x_0)>
 364 | | | | | pushValue (\x_0 -> Parsers.Brainfuck.Types.Output)
 365 | | | | |   minReads=1
 366 | | | | |   mayRaise=[ExceptionFailure]
 367 | | | | |   alwaysRaise=[]
 368 | | | | |   freeRegs=[reg]
 369 | | | | | comment "satisfy ((\\x_0 -> \\x_1 -> x_0) GHC.Types.True)"
 370 | | | | |   minReads=1
 371 | | | | |   mayRaise=[ExceptionFailure]
 372 | | | | |   alwaysRaise=[]
 373 | | | | |   freeRegs=[reg]
 374 | | | | | read (\x_0 -> GHC.Types.True)
 375 | | | | |   minReads=1
 376 | | | | |   mayRaise=[ExceptionFailure]
 377 | | | | |   alwaysRaise=[]
 378 | | | | |   freeRegs=[reg]
 379 | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)
 380 | | | | |   minReads=0
 381 | | | | |   mayRaise=[ExceptionFailure]
 382 | | | | |   alwaysRaise=[]
 383 | | | | |   freeRegs=[reg]
 384 | | | | | refJoin join
 385 | | | | |   minReads=0
 386 | | | | |   mayRaise=[ExceptionFailure]
 387 | | | | |   alwaysRaise=[]
 388 | | | | |   freeRegs=[reg]
 389 | | | | <branch (\x_0 -> (GHC.Classes.==) '[' x_0)>
 390 | | | | | pushValue (\x_0 -> \x_1 -> \x_2 -> \x_3 -> Parsers.Brainfuck.Types.Loop x_2)
 391 | | | | |   minReads=1
 392 | | | | |   mayRaise=[ExceptionFailure]
 393 | | | | |   alwaysRaise=[]
 394 | | | | |   freeRegs=[]
 395 | | | | | comment "satisfy ((\\x_0 -> \\x_1 -> x_0) GHC.Types.True)"
 396 | | | | |   minReads=1
 397 | | | | |   mayRaise=[ExceptionFailure]
 398 | | | | |   alwaysRaise=[]
 399 | | | | |   freeRegs=[]
 400 | | | | | read (\x_0 -> GHC.Types.True)
 401 | | | | |   minReads=1
 402 | | | | |   mayRaise=[ExceptionFailure]
 403 | | | | |   alwaysRaise=[]
 404 | | | | |   freeRegs=[]
 405 | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)
 406 | | | | |   minReads=0
 407 | | | | |   mayRaise=[ExceptionFailure]
 408 | | | | |   alwaysRaise=[]
 409 | | | | |   freeRegs=[]
 410 | | | | | call name
 411 | | | | |   minReads=0
 412 | | | | |   mayRaise=[ExceptionFailure]
 413 | | | | |   alwaysRaise=[]
 414 | | | | |   freeRegs=[]
 415 | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)
 416 | | | | |   minReads=0
 417 | | | | |   mayRaise=[]
 418 | | | | |   alwaysRaise=[]
 419 | | | | |   freeRegs=[]
 420 | | | | | call name
 421 | | | | |   minReads=0
 422 | | | | |   mayRaise=[]
 423 | | | | |   alwaysRaise=[]
 424 | | | | |   freeRegs=[]
 425 | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)
 426 | | | | |   minReads=1
 427 | | | | |   mayRaise=[ExceptionFailure]
 428 | | | | |   alwaysRaise=[]
 429 | | | | |   freeRegs=[reg]
 430 | | | | | comment "satisfy ((GHC.Classes.==) ']')"
 431 | | | | |   minReads=1
 432 | | | | |   mayRaise=[ExceptionFailure]
 433 | | | | |   alwaysRaise=[]
 434 | | | | |   freeRegs=[reg]
 435 | | | | | read ((GHC.Classes.==) ']')
 436 | | | | |   minReads=1
 437 | | | | |   mayRaise=[ExceptionFailure]
 438 | | | | |   alwaysRaise=[]
 439 | | | | |   freeRegs=[reg]
 440 | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)
 441 | | | | |   minReads=0
 442 | | | | |   mayRaise=[ExceptionFailure]
 443 | | | | |   alwaysRaise=[]
 444 | | | | |   freeRegs=[reg]
 445 | | | | | refJoin join
 446 | | | | |   minReads=0
 447 | | | | |   mayRaise=[ExceptionFailure]
 448 | | | | |   alwaysRaise=[]
 449 | | | | |   freeRegs=[reg]
 450 | | | | <default>
 451 | | | | | fail [FailureEmpty]
 452 | | | | |   minReads=0
 453 | | | | |   mayRaise=[ExceptionFailure]
 454 | | | | |   alwaysRaise=[ExceptionFailure]
 455 | | | | |   freeRegs=[]
 456 | | <ko>
 457 | | | comment "raiseAgainIfConsumed"
 458 | | |   minReads=0
 459 | | |   mayRaise=[ExceptionFailure]
 460 | | |   alwaysRaise=[]
 461 | | |   freeRegs=[reg]
 462 | | | saveInput
 463 | | |   minReads=0
 464 | | |   mayRaise=[ExceptionFailure]
 465 | | |   alwaysRaise=[]
 466 | | |   freeRegs=[reg]
 467 | | | lift2Value (\(Data.Text.Internal.Text _ i_0 _) (Data.Text.Internal.Text _
 468 | | |                                                                j_1
 469 | | |                                                                _) -> i_0 GHC.Classes.== j_1)
 470 | | |   minReads=0
 471 | | |   mayRaise=[ExceptionFailure]
 472 | | |   alwaysRaise=[]
 473 | | |   freeRegs=[reg]
 474 | | | choicesBranch
 475 | | |   minReads=0
 476 | | |   mayRaise=[ExceptionFailure]
 477 | | |   alwaysRaise=[]
 478 | | |   freeRegs=[reg]
 479 | | | | <branch (\x_0 -> x_0)>
 480 | | | | | readRegister reg
 481 | | | | |   minReads=0
 482 | | | | |   mayRaise=[]
 483 | | | | |   alwaysRaise=[]
 484 | | | | |   freeRegs=[reg]
 485 | | | | | pushValue GHC.Types.[]
 486 | | | | |   minReads=0
 487 | | | | |   mayRaise=[]
 488 | | | | |   alwaysRaise=[]
 489 | | | | |   freeRegs=[]
 490 | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)
 491 | | | | |   minReads=0
 492 | | | | |   mayRaise=[]
 493 | | | | |   alwaysRaise=[]
 494 | | | | |   freeRegs=[]
 495 | | | | | ret
 496 | | | | |   minReads=0
 497 | | | | |   mayRaise=[]
 498 | | | | |   alwaysRaise=[]
 499 | | | | |   freeRegs=[]
 500 | | | | <default>
 501 | | | | | fail []
 502 | | | | |   minReads=0
 503 | | | | |   mayRaise=[ExceptionFailure]
 504 | | | | |   alwaysRaise=[ExceptionFailure]
 505 | | | | |   freeRegs=[]
 506 pushValue (\x_0 -> \x_1 -> GHC.Show.show x_1)
 507   minReads=0
 508   mayRaise=[ExceptionFailure]
 509   alwaysRaise=[]
 510   freeRegs=[]
 511 call name
 512   minReads=0
 513   mayRaise=[ExceptionFailure]
 514   alwaysRaise=[]
 515   freeRegs=[]
 516 lift2Value (\x_0 -> \x_1 -> x_0 x_1)
 517   minReads=0
 518   mayRaise=[ExceptionFailure]
 519   alwaysRaise=[]
 520   freeRegs=[]
 521 call name
 522   minReads=0
 523   mayRaise=[ExceptionFailure]
 524   alwaysRaise=[]
 525   freeRegs=[]
 526 lift2Value (\x_0 -> \x_1 -> x_0 x_1)
 527   minReads=0
 528   mayRaise=[]
 529   alwaysRaise=[]
 530   freeRegs=[]
 531 ret
 532   minReads=0
 533   mayRaise=[]
 534   alwaysRaise=[]
 535   freeRegs=[]