tests/Golden/Machine/G20.expected.txt

   1 pushValue (\x_0 -> \x_1 -> GHC.Show.show GHC.Tuple.())
   2   minReads=3
   3   mayRaise=[ExceptionFailure]
   4   alwaysRaise=[]
   5   freeRegs=[]
   6 join join
   7   minReads=3
   8   mayRaise=[ExceptionFailure]
   9   alwaysRaise=[]
  10   freeRegs=[]
  11 | lift2Value (\x_0 -> \x_1 -> x_0 x_1)
  12 |   minReads=3
  13 |   mayRaise=[ExceptionFailure]
  14 |   alwaysRaise=[]
  15 |   freeRegs=[]
  16 | catch ExceptionFailure
  17 |   minReads=3
  18 |   mayRaise=[ExceptionFailure]
  19 |   alwaysRaise=[]
  20 |   freeRegs=[]
  21 | | <catchScope>
  22 | | | pushValue (\x_0 -> \x_1 -> \x_2 -> (GHC.Types.:) 'd' ((GHC.Types.:) 'e' ((GHC.Types.:) 'f' GHC.Types.[])))
  23 | | |   minReads=3
  24 | | |   mayRaise=[ExceptionFailure]
  25 | | |   alwaysRaise=[]
  26 | | |   freeRegs=[]
  27 | | | comment "satisfy ((GHC.Classes.==) 'd')"
  28 | | |   minReads=3
  29 | | |   mayRaise=[ExceptionFailure]
  30 | | |   alwaysRaise=[]
  31 | | |   freeRegs=[]
  32 | | | read ((GHC.Classes.==) 'd')
  33 | | |   minReads=3
  34 | | |   mayRaise=[ExceptionFailure]
  35 | | |   alwaysRaise=[]
  36 | | |   freeRegs=[]
  37 | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)
  38 | | |   minReads=2
  39 | | |   mayRaise=[ExceptionFailure]
  40 | | |   alwaysRaise=[]
  41 | | |   freeRegs=[]
  42 | | | comment "satisfy ((GHC.Classes.==) 'e')"
  43 | | |   minReads=2
  44 | | |   mayRaise=[ExceptionFailure]
  45 | | |   alwaysRaise=[]
  46 | | |   freeRegs=[]
  47 | | | read ((GHC.Classes.==) 'e')
  48 | | |   minReads=2
  49 | | |   mayRaise=[ExceptionFailure]
  50 | | |   alwaysRaise=[]
  51 | | |   freeRegs=[]
  52 | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)
  53 | | |   minReads=1
  54 | | |   mayRaise=[ExceptionFailure]
  55 | | |   alwaysRaise=[]
  56 | | |   freeRegs=[]
  57 | | | comment "satisfy ((GHC.Classes.==) 'f')"
  58 | | |   minReads=1
  59 | | |   mayRaise=[ExceptionFailure]
  60 | | |   alwaysRaise=[]
  61 | | |   freeRegs=[]
  62 | | | read ((GHC.Classes.==) 'f')
  63 | | |   minReads=1
  64 | | |   mayRaise=[ExceptionFailure]
  65 | | |   alwaysRaise=[]
  66 | | |   freeRegs=[]
  67 | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)
  68 | | |   minReads=0
  69 | | |   mayRaise=[]
  70 | | |   alwaysRaise=[]
  71 | | |   freeRegs=[]
  72 | | | commit ExceptionFailure
  73 | | |   minReads=0
  74 | | |   mayRaise=[]
  75 | | |   alwaysRaise=[]
  76 | | |   freeRegs=[]
  77 | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)
  78 | | |   minReads=0
  79 | | |   mayRaise=[]
  80 | | |   alwaysRaise=[]
  81 | | |   freeRegs=[]
  82 | | | ret
  83 | | |   minReads=0
  84 | | |   mayRaise=[]
  85 | | |   alwaysRaise=[]
  86 | | |   freeRegs=[]
  87 | | <onException ExceptionFailure>
  88 | | | loadInput
  89 | | |   minReads=0
  90 | | |   mayRaise=[ExceptionFailure]
  91 | | |   alwaysRaise=[ExceptionFailure]
  92 | | |   freeRegs=[]
  93 | | | fail []
  94 | | |   minReads=0
  95 | | |   mayRaise=[ExceptionFailure]
  96 | | |   alwaysRaise=[ExceptionFailure]
  97 | | |   freeRegs=[]
  98 catch ExceptionFailure
  99   minReads=3
 100   mayRaise=[ExceptionFailure]
 101   alwaysRaise=[]
 102   freeRegs=[]
 103 | <catchScope>
 104 | | catch ExceptionFailure
 105 | |   minReads=6
 106 | |   mayRaise=[ExceptionFailure]
 107 | |   alwaysRaise=[]
 108 | |   freeRegs=[]
 109 | | | <catchScope>
 110 | | | | pushValue (\x_0 -> \x_1 -> \x_2 -> (GHC.Types.:) 'a' ((GHC.Types.:) 'b' ((GHC.Types.:) 'c' GHC.Types.[])))
 111 | | | |   minReads=6
 112 | | | |   mayRaise=[ExceptionFailure]
 113 | | | |   alwaysRaise=[]
 114 | | | |   freeRegs=[]
 115 | | | | comment "satisfy ((GHC.Classes.==) 'a')"
 116 | | | |   minReads=6
 117 | | | |   mayRaise=[ExceptionFailure]
 118 | | | |   alwaysRaise=[]
 119 | | | |   freeRegs=[]
 120 | | | | read ((GHC.Classes.==) 'a')
 121 | | | |   minReads=6
 122 | | | |   mayRaise=[ExceptionFailure]
 123 | | | |   alwaysRaise=[]
 124 | | | |   freeRegs=[]
 125 | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)
 126 | | | |   minReads=5
 127 | | | |   mayRaise=[ExceptionFailure]
 128 | | | |   alwaysRaise=[]
 129 | | | |   freeRegs=[]
 130 | | | | comment "satisfy ((GHC.Classes.==) 'b')"
 131 | | | |   minReads=5
 132 | | | |   mayRaise=[ExceptionFailure]
 133 | | | |   alwaysRaise=[]
 134 | | | |   freeRegs=[]
 135 | | | | read ((GHC.Classes.==) 'b')
 136 | | | |   minReads=5
 137 | | | |   mayRaise=[ExceptionFailure]
 138 | | | |   alwaysRaise=[]
 139 | | | |   freeRegs=[]
 140 | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)
 141 | | | |   minReads=4
 142 | | | |   mayRaise=[ExceptionFailure]
 143 | | | |   alwaysRaise=[]
 144 | | | |   freeRegs=[]
 145 | | | | comment "satisfy ((GHC.Classes.==) 'c')"
 146 | | | |   minReads=4
 147 | | | |   mayRaise=[ExceptionFailure]
 148 | | | |   alwaysRaise=[]
 149 | | | |   freeRegs=[]
 150 | | | | read ((GHC.Classes.==) 'c')
 151 | | | |   minReads=4
 152 | | | |   mayRaise=[ExceptionFailure]
 153 | | | |   alwaysRaise=[]
 154 | | | |   freeRegs=[]
 155 | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)
 156 | | | |   minReads=3
 157 | | | |   mayRaise=[ExceptionFailure]
 158 | | | |   alwaysRaise=[]
 159 | | | |   freeRegs=[]
 160 | | | | commit ExceptionFailure
 161 | | | |   minReads=3
 162 | | | |   mayRaise=[ExceptionFailure]
 163 | | | |   alwaysRaise=[]
 164 | | | |   freeRegs=[]
 165 | | | | commit ExceptionFailure
 166 | | | |   minReads=3
 167 | | | |   mayRaise=[ExceptionFailure]
 168 | | | |   alwaysRaise=[]
 169 | | | |   freeRegs=[]
 170 | | | | refJoin join
 171 | | | |   minReads=3
 172 | | | |   mayRaise=[ExceptionFailure]
 173 | | | |   alwaysRaise=[]
 174 | | | |   freeRegs=[]
 175 | | | <onException ExceptionFailure>
 176 | | | | loadInput
 177 | | | |   minReads=0
 178 | | | |   mayRaise=[ExceptionFailure]
 179 | | | |   alwaysRaise=[ExceptionFailure]
 180 | | | |   freeRegs=[]
 181 | | | | fail []
 182 | | | |   minReads=0
 183 | | | |   mayRaise=[ExceptionFailure]
 184 | | | |   alwaysRaise=[ExceptionFailure]
 185 | | | |   freeRegs=[]
 186 | <onException ExceptionFailure>
 187 | | comment "raiseAgainIfConsumed"
 188 | |   minReads=3
 189 | |   mayRaise=[ExceptionFailure]
 190 | |   alwaysRaise=[]
 191 | |   freeRegs=[]
 192 | | saveInput
 193 | |   minReads=3
 194 | |   mayRaise=[ExceptionFailure]
 195 | |   alwaysRaise=[]
 196 | |   freeRegs=[]
 197 | | lift2Value (\(Data.Text.Internal.Text _ i_0 _) (Data.Text.Internal.Text _
 198 | |                                                                j_1
 199 | |                                                                _) -> i_0 GHC.Classes.== j_1)
 200 | |   minReads=3
 201 | |   mayRaise=[ExceptionFailure]
 202 | |   alwaysRaise=[]
 203 | |   freeRegs=[]
 204 | | choicesBranch
 205 | |   minReads=3
 206 | |   mayRaise=[ExceptionFailure]
 207 | |   alwaysRaise=[]
 208 | |   freeRegs=[]
 209 | | | <branch (\x_0 -> x_0)>
 210 | | | | catch ExceptionFailure
 211 | | | |   minReads=3
 212 | | | |   mayRaise=[ExceptionFailure]
 213 | | | |   alwaysRaise=[]
 214 | | | |   freeRegs=[]
 215 | | | | | <catchScope>
 216 | | | | | | pushValue GHC.Types.[]
 217 | | | | | |   minReads=3
 218 | | | | | |   mayRaise=[ExceptionFailure]
 219 | | | | | |   alwaysRaise=[]
 220 | | | | | |   freeRegs=[]
 221 | | | | | | commit ExceptionFailure
 222 | | | | | |   minReads=3
 223 | | | | | |   mayRaise=[ExceptionFailure]
 224 | | | | | |   alwaysRaise=[]
 225 | | | | | |   freeRegs=[]
 226 | | | | | | refJoin join
 227 | | | | | |   minReads=3
 228 | | | | | |   mayRaise=[ExceptionFailure]
 229 | | | | | |   alwaysRaise=[]
 230 | | | | | |   freeRegs=[]
 231 | | | | | <onException ExceptionFailure>
 232 | | | | | | loadInput
 233 | | | | | |   minReads=0
 234 | | | | | |   mayRaise=[ExceptionFailure]
 235 | | | | | |   alwaysRaise=[ExceptionFailure]
 236 | | | | | |   freeRegs=[]
 237 | | | | | | fail []
 238 | | | | | |   minReads=0
 239 | | | | | |   mayRaise=[ExceptionFailure]
 240 | | | | | |   alwaysRaise=[ExceptionFailure]
 241 | | | | | |   freeRegs=[]
 242 | | | <default>
 243 | | | | fail []
 244 | | | |   minReads=0
 245 | | | |   mayRaise=[ExceptionFailure]
 246 | | | |   alwaysRaise=[ExceptionFailure]
 247 | | | |   freeRegs=[]