test/Golden/Machine/G13.expected.txt

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