# Ticket #5302: Unboxed_late_dmd.dump-stg

File Unboxed_late_dmd.dump-stg, 170.0 KB (added by , 2 years ago) |
---|

Line | |
---|---|

1 | |

2 | ==================== Pre unarise: ==================== |

3 | 2018-02-15 07:12:52.731513615 UTC |

4 | |

5 | Unboxed.$WDeep [InlPrag=INLINE[2]] |

6 | :: forall v a. |

7 | v |

8 | -> Unboxed.Digit a |

9 | -> Unboxed.FingerTree v (Unboxed.Node v a) |

10 | -> Unboxed.Digit a |

11 | -> Unboxed.FingerTree v a |

12 | [GblId[DataConWrapper], |

13 | Arity=4, |

14 | Caf=NoCafRefs, |

15 | Str=<S,U><S,U><L,U><S,U>m3, |

16 | Unf=OtherCon []] = |

17 | [] \r [dt_s4AU dt_s4AV dt_s4AW dt_s4AX] |

18 | case dt_s4AU of dt_s4AY { |

19 | __DEFAULT -> |

20 | case dt_s4AV of dt_s4AZ { |

21 | __DEFAULT -> |

22 | case dt_s4AX of dt_s4B0 { |

23 | __DEFAULT -> Unboxed.Deep [dt_s4AY dt_s4AZ dt_s4AW dt_s4B0]; |

24 | }; |

25 | }; |

26 | }; |

27 | |

28 | Unboxed.$WNode2 [InlPrag=INLINE[2]] |

29 | :: forall v a. v -> a -> a -> Unboxed.Node v a |

30 | [GblId[DataConWrapper], |

31 | Arity=3, |

32 | Caf=NoCafRefs, |

33 | Str=<S,U><L,U><L,U>m1, |

34 | Unf=OtherCon []] = |

35 | [] \r [dt_s4B1 dt_s4B2 dt_s4B3] |

36 | case dt_s4B1 of dt_s4B4 { |

37 | __DEFAULT -> Unboxed.Node2 [dt_s4B4 dt_s4B2 dt_s4B3]; |

38 | }; |

39 | |

40 | Unboxed.$WNode3 [InlPrag=INLINE[2]] |

41 | :: forall v a. v -> a -> a -> a -> Unboxed.Node v a |

42 | [GblId[DataConWrapper], |

43 | Arity=4, |

44 | Caf=NoCafRefs, |

45 | Str=<S,U><L,U><L,U><L,U>m2, |

46 | Unf=OtherCon []] = |

47 | [] \r [dt_s4B5 dt_s4B6 dt_s4B7 dt_s4B8] |

48 | case dt_s4B5 of dt_s4B9 { |

49 | __DEFAULT -> Unboxed.Node3 [dt_s4B9 dt_s4B6 dt_s4B7 dt_s4B8]; |

50 | }; |

51 | |

52 | Unboxed.$fMonoidSize_$c<> [InlPrag=INLINE (sat-args=2)] |

53 | :: Unboxed.Size -> Unboxed.Size -> Unboxed.Size |

54 | [GblId, |

55 | Arity=2, |

56 | Caf=NoCafRefs, |

57 | Str=<S(S),1*U(U)><S(S),1*U(U)>m, |

58 | Unf=OtherCon []] = |

59 | [] \r [eta_B2 eta_B1] GHC.Num.$fNumInt_$c+ eta_B2 eta_B1; |

60 | |

61 | Unboxed.$wgo1 [InlPrag=NOUSERINLINE[0], Occ=LoopBreaker] |

62 | :: GHC.Prim.Int# -> [Unboxed.Size] -> GHC.Prim.Int# |

63 | [GblId, |

64 | Arity=2, |

65 | Caf=NoCafRefs, |

66 | Str=<S,U><S,1*U>, |

67 | Unf=OtherCon []] = |

68 | [] \r [ww_s4Ba w_s4Bb] |

69 | case w_s4Bb of { |

70 | [] -> ww_s4Ba; |

71 | : c_s4Bd [Occ=Once] cs_s4Be [Occ=Once] -> |

72 | case c_s4Bd of { |

73 | GHC.Types.I# ww2_s4Bg [Occ=Once] -> |

74 | case Unboxed.$wgo1 ww2_s4Bg cs_s4Be of ww3_s4Bh { |

75 | __DEFAULT -> +# [ww_s4Ba ww3_s4Bh]; |

76 | }; |

77 | }; |

78 | }; |

79 | |

80 | Unboxed.$fSemigroupSize_go [InlPrag=NOUSERINLINE[0]] |

81 | :: Unboxed.Size -> [Unboxed.Size] -> Unboxed.Size |

82 | [GblId, |

83 | Arity=2, |

84 | Caf=NoCafRefs, |

85 | Str=<S(S),1*U(U)><S,1*U>m, |

86 | Unf=OtherCon []] = |

87 | [] \r [w_s4Bi w1_s4Bj] |

88 | case w_s4Bi of { |

89 | GHC.Types.I# ww1_s4Bl [Occ=Once] -> |

90 | case Unboxed.$wgo1 ww1_s4Bl w1_s4Bj of ww2_s4Bm { |

91 | __DEFAULT -> GHC.Types.I# [ww2_s4Bm]; |

92 | }; |

93 | }; |

94 | |

95 | Unboxed.$fSemigroupSize_$csconcat |

96 | :: GHC.Base.NonEmpty Unboxed.Size -> Unboxed.Size |

97 | [GblId, |

98 | Arity=1, |

99 | Caf=NoCafRefs, |

100 | Str=<S(S(S)S),1*U(1*U(U),1*U)>m, |

101 | Unf=OtherCon []] = |

102 | [] \r [ds_s4Bn] |

103 | case ds_s4Bn of { |

104 | GHC.Base.:| a1_s4Bp [Occ=Once] as_s4Bq [Occ=Once] -> |

105 | Unboxed.$fSemigroupSize_go a1_s4Bp as_s4Bq; |

106 | }; |

107 | |

108 | Unboxed.$fSemigroupSize [InlPrag=NOUSERINLINE CONLIKE] |

109 | :: GHC.Base.Semigroup Unboxed.Size |

110 | [GblId[DFunId], Str=m] = |

111 | CCS_DONT_CARE GHC.Base.C:Semigroup! [Unboxed.$fMonoidSize_$c<> |

112 | Unboxed.$fSemigroupSize_$csconcat |

113 | Unboxed.$fSemigroupSize_$cstimes]; |

114 | Unboxed.$fSemigroupSize_$cstimes [Occ=LoopBreaker] |

115 | :: forall b. |

116 | GHC.Real.Integral b => |

117 | b -> Unboxed.Size -> Unboxed.Size |

118 | [GblId, Arity=1, Str=<L,U>, Unf=OtherCon []] = |

119 | [] \r [$dIntegral_s4Br] |

120 | Data.Semigroup.Internal.stimesDefault |

121 | $dIntegral_s4Br Unboxed.$fSemigroupSize; |

122 | |

123 | $cmempty_r3mS :: GHC.Types.Int |

124 | [GblId, Caf=NoCafRefs, Str=m, Unf=OtherCon []] = |

125 | CCS_DONT_CARE GHC.Types.I#! [0#]; |

126 | |

127 | Unboxed.$fMonoidSize_$cmempty [InlPrag=INLINE (sat-args=0)] |

128 | :: Unboxed.Size |

129 | [GblId, Str=m, Unf=OtherCon []] = |

130 | [] \u [] $cmempty_r3mS; |

131 | |

132 | Unboxed.$wgo [InlPrag=NOUSERINLINE[0], Occ=LoopBreaker] |

133 | :: [Unboxed.Size] -> GHC.Prim.Int# |

134 | [GblId, Arity=1, Caf=NoCafRefs, Str=<S,1*U>, Unf=OtherCon []] = |

135 | [] \r [w_s4Bs] |

136 | case w_s4Bs of { |

137 | [] -> 0#; |

138 | : y_s4Bu [Occ=Once] ys_s4Bv [Occ=Once] -> |

139 | case y_s4Bu of { |

140 | GHC.Types.I# x_s4Bx [Occ=Once] -> |

141 | case Unboxed.$wgo ys_s4Bv of ww_s4By { |

142 | __DEFAULT -> +# [x_s4Bx ww_s4By]; |

143 | }; |

144 | }; |

145 | }; |

146 | |

147 | Unboxed.$fMonoidSize_go [InlPrag=NOUSERINLINE[0]] |

148 | :: [Unboxed.Size] -> Unboxed.Size |

149 | [GblId, Arity=1, Caf=NoCafRefs, Str=<S,1*U>m, Unf=OtherCon []] = |

150 | [] \r [w_s4Bz] |

151 | case Unboxed.$wgo w_s4Bz of ww_s4BA { |

152 | __DEFAULT -> GHC.Types.I# [ww_s4BA]; |

153 | }; |

154 | |

155 | Unboxed.$fMonoidSize [InlPrag=NOUSERINLINE CONLIKE] |

156 | :: GHC.Base.Monoid Unboxed.Size |

157 | [GblId[DFunId], Str=m] = |

158 | CCS_DONT_CARE GHC.Base.C:Monoid! [Unboxed.$fSemigroupSize |

159 | Unboxed.$fMonoidSize_$cmempty |

160 | Unboxed.$fMonoidSize_$c<> |

161 | Unboxed.$fMonoidSize_go]; |

162 | |

163 | $dIP_r4A5 :: GHC.Prim.Addr# |

164 | [GblId, Caf=NoCafRefs, Unf=OtherCon []] = |

165 | "error"#; |

166 | |

167 | $dIP1_r4A6 :: [GHC.Types.Char] |

168 | [GblId] = |

169 | [] \u [] GHC.CString.unpackCString# $dIP_r4A5; |

170 | |

171 | loc_r4A7 :: GHC.Types.Int |

172 | [GblId, Caf=NoCafRefs, Str=m, Unf=OtherCon []] = |

173 | CCS_DONT_CARE GHC.Types.I#! [47#]; |

174 | |

175 | loc1_r4A8 :: GHC.Types.Int |

176 | [GblId, Caf=NoCafRefs, Str=m, Unf=OtherCon []] = |

177 | CCS_DONT_CARE GHC.Types.I#! [34#]; |

178 | |

179 | loc2_r4A9 :: GHC.Types.Int |

180 | [GblId, Caf=NoCafRefs, Str=m, Unf=OtherCon []] = |

181 | CCS_DONT_CARE GHC.Types.I#! [16#]; |

182 | |

183 | loc3_r4Aa :: GHC.Prim.Addr# |

184 | [GblId, Caf=NoCafRefs, Unf=OtherCon []] = |

185 | "Unboxed.hs"#; |

186 | |

187 | loc4_r4Ab :: [GHC.Types.Char] |

188 | [GblId] = |

189 | [] \u [] GHC.CString.unpackCString# loc3_r4Aa; |

190 | |

191 | Unboxed.$trModule2 :: GHC.Prim.Addr# |

192 | [GblId, Caf=NoCafRefs, Unf=OtherCon []] = |

193 | "Unboxed"#; |

194 | |

195 | loc5_r4Ac :: [GHC.Types.Char] |

196 | [GblId] = |

197 | [] \u [] GHC.CString.unpackCString# Unboxed.$trModule2; |

198 | |

199 | Unboxed.$trModule4 :: GHC.Prim.Addr# |

200 | [GblId, Caf=NoCafRefs, Unf=OtherCon []] = |

201 | "main"#; |

202 | |

203 | loc6_r4Ad :: [GHC.Types.Char] |

204 | [GblId] = |

205 | [] \u [] GHC.CString.unpackCString# Unboxed.$trModule4; |

206 | |

207 | $dIP2_r4Ae :: GHC.Stack.Types.SrcLoc |

208 | [GblId, Str=m, Unf=OtherCon []] = |

209 | CCS_DONT_CARE GHC.Stack.Types.SrcLoc! [loc6_r4Ad |

210 | loc5_r4Ac |

211 | loc4_r4Ab |

212 | loc1_r4A8 |

213 | loc2_r4A9 |

214 | loc1_r4A8 |

215 | loc_r4A7]; |

216 | |

217 | $dIP3_r4Af :: GHC.Stack.Types.CallStack |

218 | [GblId, Str=m2, Unf=OtherCon []] = |

219 | CCS_DONT_CARE GHC.Stack.Types.PushCallStack! [$dIP1_r4A6 |

220 | $dIP2_r4Ae |

221 | GHC.Stack.Types.EmptyCallStack]; |

222 | |

223 | lvl_r4Ag :: GHC.Prim.Addr# |

224 | [GblId, Caf=NoCafRefs, Unf=OtherCon []] = |

225 | "splitTree of Empty tree"#; |

226 | |

227 | lvl1_r4Ah :: [GHC.Types.Char] |

228 | [GblId] = |

229 | [] \u [] GHC.CString.unpackCString# lvl_r4Ag; |

230 | |

231 | lvl2_r4Ai :: GHC.Prim.Addr# |

232 | [GblId, Caf=NoCafRefs, Unf=OtherCon []] = |

233 | "undefined"#; |

234 | |

235 | lvl3_r4Aj :: [GHC.Types.Char] |

236 | [GblId] = |

237 | [] \u [] GHC.CString.unpackCString# lvl2_r4Ai; |

238 | |

239 | lvl4_r4Ak :: GHC.Types.Int |

240 | [GblId, Caf=NoCafRefs, Str=m, Unf=OtherCon []] = |

241 | CCS_DONT_CARE GHC.Types.I#! [44#]; |

242 | |

243 | lvl5_r4Al :: GHC.Types.Int |

244 | [GblId, Caf=NoCafRefs, Str=m, Unf=OtherCon []] = |

245 | CCS_DONT_CARE GHC.Types.I#! [56#]; |

246 | |

247 | lvl6_r4Am :: GHC.Stack.Types.SrcLoc |

248 | [GblId, Str=m, Unf=OtherCon []] = |

249 | CCS_DONT_CARE GHC.Stack.Types.SrcLoc! [loc6_r4Ad |

250 | loc5_r4Ac |

251 | loc4_r4Ab |

252 | lvl4_r4Ak |

253 | loc_r4A7 |

254 | lvl4_r4Ak |

255 | lvl5_r4Al]; |

256 | |

257 | lvl7_r4An :: GHC.Stack.Types.CallStack |

258 | [GblId, Str=m2, Unf=OtherCon []] = |

259 | CCS_DONT_CARE GHC.Stack.Types.PushCallStack! [lvl3_r4Aj |

260 | lvl6_r4Am |

261 | GHC.Stack.Types.EmptyCallStack]; |

262 | |

263 | lvl8_r4Ao |

264 | :: forall b. |

265 | Unboxed.FingerTree Unboxed.Size (Unboxed.Node Unboxed.Size b) |

266 | [GblId, Str=x] = |

267 | [] \u [] GHC.Err.undefined lvl7_r4An; |

268 | |

269 | lvl9_r4Ap :: GHC.Types.Int |

270 | [GblId, Caf=NoCafRefs, Str=m, Unf=OtherCon []] = |

271 | CCS_DONT_CARE GHC.Types.I#! [38#]; |

272 | |

273 | lvl10_r4Aq :: GHC.Types.Int |

274 | [GblId, Caf=NoCafRefs, Str=m, Unf=OtherCon []] = |

275 | CCS_DONT_CARE GHC.Types.I#! [65#]; |

276 | |

277 | lvl11_r4Ar :: GHC.Stack.Types.SrcLoc |

278 | [GblId, Str=m, Unf=OtherCon []] = |

279 | CCS_DONT_CARE GHC.Stack.Types.SrcLoc! [loc6_r4Ad |

280 | loc5_r4Ac |

281 | loc4_r4Ab |

282 | lvl9_r4Ap |

283 | lvl5_r4Al |

284 | lvl9_r4Ap |

285 | lvl10_r4Aq]; |

286 | |

287 | lvl12_r4As :: GHC.Stack.Types.CallStack |

288 | [GblId, Str=m2, Unf=OtherCon []] = |

289 | CCS_DONT_CARE GHC.Stack.Types.PushCallStack! [lvl3_r4Aj |

290 | lvl11_r4Ar |

291 | GHC.Stack.Types.EmptyCallStack]; |

292 | |

293 | lvl13_r4At |

294 | :: forall b. |

295 | Unboxed.Digit (Unboxed.Node Unboxed.Size b) |

296 | -> Unboxed.FingerTree Unboxed.Size (Unboxed.Node Unboxed.Size b) |

297 | [GblId, Str=x] = |

298 | [] \u [] GHC.Err.undefined lvl12_r4As; |

299 | |

300 | lvl14_r4Au :: GHC.Types.Int |

301 | [GblId, Caf=NoCafRefs, Str=m, Unf=OtherCon []] = |

302 | CCS_DONT_CARE GHC.Types.I#! [29#]; |

303 | |

304 | lvl15_r4Av :: GHC.Types.Int |

305 | [GblId, Caf=NoCafRefs, Str=m, Unf=OtherCon []] = |

306 | CCS_DONT_CARE GHC.Types.I#! [61#]; |

307 | |

308 | lvl16_r4Aw :: GHC.Types.Int |

309 | [GblId, Caf=NoCafRefs, Str=m, Unf=OtherCon []] = |

310 | CCS_DONT_CARE GHC.Types.I#! [70#]; |

311 | |

312 | lvl17_r4Ax :: GHC.Stack.Types.SrcLoc |

313 | [GblId, Str=m, Unf=OtherCon []] = |

314 | CCS_DONT_CARE GHC.Stack.Types.SrcLoc! [loc6_r4Ad |

315 | loc5_r4Ac |

316 | loc4_r4Ab |

317 | lvl14_r4Au |

318 | lvl15_r4Av |

319 | lvl14_r4Au |

320 | lvl16_r4Aw]; |

321 | |

322 | lvl18_r4Ay :: GHC.Stack.Types.CallStack |

323 | [GblId, Str=m2, Unf=OtherCon []] = |

324 | CCS_DONT_CARE GHC.Stack.Types.PushCallStack! [lvl3_r4Aj |

325 | lvl17_r4Ax |

326 | GHC.Stack.Types.EmptyCallStack]; |

327 | |

328 | lvl19_r4Az |

329 | :: forall c. |

330 | Unboxed.FingerTree Unboxed.Size (Unboxed.Node Unboxed.Size c) |

331 | [GblId, Str=x] = |

332 | [] \u [] GHC.Err.undefined lvl18_r4Ay; |

333 | |

334 | Unboxed.$wmySplit [InlPrag=NOUSERINLINE[0]] |

335 | :: forall c. |

336 | GHC.Types.Int |

337 | -> Unboxed.FingerTree Unboxed.Size (Unboxed.Node Unboxed.Size c) |

338 | -> (# Unboxed.FingerTree |

339 | Unboxed.Size (Unboxed.Node Unboxed.Size c), |

340 | Unboxed.FingerTree Unboxed.Size (Unboxed.Node Unboxed.Size c) #) |

341 | [GblId, Arity=2, Str=<L,1*U(U)><S,1*U>, Unf=OtherCon []] = |

342 | [] \r [w_s4BB w1_s4BC] |

343 | case w1_s4BC of { |

344 | Unboxed.Empty -> GHC.Err.error $dIP3_r4Af lvl1_r4Ah; |

345 | Unboxed.Single _ [Occ=Dead] -> (#,#) [Unboxed.Empty lvl19_r4Az]; |

346 | Unboxed.Deep _ [Occ=Dead] |

347 | pr_s4BH |

348 | _ [Occ=Dead] |

349 | sf_s4BJ [Occ=Once!] -> |

350 | let-no-escape { |

351 | $w$j_s4BK [InlPrag=NOUSERINLINE[0], |

352 | Occ=Once*!T[1], |

353 | Dmd=<C(S),1*C1(U(U,U))>] |

354 | :: GHC.Prim.Int# |

355 | -> (# Unboxed.FingerTree |

356 | Unboxed.Size (Unboxed.Node Unboxed.Size c_s45o), |

357 | Unboxed.FingerTree |

358 | Unboxed.Size (Unboxed.Node Unboxed.Size c_s45o) #) |

359 | [LclId[JoinId(1)], Arity=1, Str=<S,U>, Unf=OtherCon []] = |

360 | sat-only [w_s4BB pr_s4BH sf_s4BJ] \r [w2_s4BL] |

361 | case w_s4BB of { |

362 | GHC.Types.I# y_s4BN -> |

363 | case ># [w2_s4BL y_s4BN] of { |

364 | __DEFAULT -> |

365 | case sf_s4BJ of { |

366 | Unboxed.One _ [Occ=Dead] -> (#,#) [lvl8_r4Ao lvl19_r4Az]; |

367 | Unboxed.Two a_s4BR [Occ=Once] _ [Occ=Dead] -> |

368 | case a_s4BR of { |

369 | __DEFAULT -> (#,#) [lvl8_r4Ao lvl19_r4Az]; |

370 | }; |

371 | Unboxed.Three a_s4BU [Occ=Once!] |

372 | b_s4BV [Occ=Once*] |

373 | _ [Occ=Dead] -> |

374 | case a_s4BU of { |

375 | Unboxed.Node2 v_s4BY [Occ=Once] |

376 | _ [Occ=Dead] |

377 | _ [Occ=Dead] -> |

378 | case v_s4BY of { |

379 | GHC.Types.I# y1_s4C2 [Occ=Once] -> |

380 | case +# [w2_s4BL y1_s4C2] of sat_s4C3 { |

381 | __DEFAULT -> |

382 | case ># [sat_s4C3 y_s4BN] of { |

383 | __DEFAULT -> |

384 | case b_s4BV of { |

385 | __DEFAULT -> |

386 | (#,#) [lvl8_r4Ao |

387 | lvl19_r4Az]; |

388 | }; |

389 | 1# -> (#,#) [lvl8_r4Ao lvl19_r4Az]; |

390 | }; |

391 | }; |

392 | }; |

393 | Unboxed.Node3 v_s4C6 [Occ=Once] |

394 | _ [Occ=Dead] |

395 | _ [Occ=Dead] |

396 | _ [Occ=Dead] -> |

397 | case v_s4C6 of { |

398 | GHC.Types.I# y1_s4Cb [Occ=Once] -> |

399 | case +# [w2_s4BL y1_s4Cb] of sat_s4Cc { |

400 | __DEFAULT -> |

401 | case ># [sat_s4Cc y_s4BN] of { |

402 | __DEFAULT -> |

403 | case b_s4BV of { |

404 | __DEFAULT -> |

405 | (#,#) [lvl8_r4Ao |

406 | lvl19_r4Az]; |

407 | }; |

408 | 1# -> (#,#) [lvl8_r4Ao lvl19_r4Az]; |

409 | }; |

410 | }; |

411 | }; |

412 | }; |

413 | Unboxed.Four a_s4Cf [Occ=Once!] |

414 | b_s4Cg [Occ=Once!] |

415 | c1_s4Ch [Occ=Once*] |

416 | _ [Occ=Dead] -> |

417 | let-no-escape { |

418 | $j_s4Cj [Occ=Once*!T[1], Dmd=<C(S),1*C1(U(U,U))>] |

419 | :: GHC.Prim.Int# |

420 | -> (# Unboxed.FingerTree |

421 | Unboxed.Size |

422 | (Unboxed.Node Unboxed.Size c_s45o), |

423 | Unboxed.FingerTree |

424 | Unboxed.Size |

425 | (Unboxed.Node Unboxed.Size c_s45o) #) |

426 | [LclId[JoinId(1)], |

427 | Arity=1, |

428 | Str=<S,U>, |

429 | Unf=OtherCon []] = |

430 | sat-only [y_s4BN b_s4Cg c1_s4Ch] \r [x_s4Ck] |

431 | case ># [x_s4Ck y_s4BN] of { |

432 | __DEFAULT -> |

433 | case b_s4Cg of { |

434 | Unboxed.Node2 v_s4Cn [Occ=Once] |

435 | _ [Occ=Dead] |

436 | _ [Occ=Dead] -> |

437 | case v_s4Cn of { |

438 | GHC.Types.I# y1_s4Cr [Occ=Once] -> |

439 | case |

440 | +# [x_s4Ck y1_s4Cr] |

441 | of |

442 | sat_s4Cs |

443 | { __DEFAULT -> |

444 | case |

445 | ># [sat_s4Cs y_s4BN] |

446 | of |

447 | { __DEFAULT -> |

448 | case c1_s4Ch of { |

449 | __DEFAULT -> |

450 | (#,#) [lvl8_r4Ao |

451 | lvl19_r4Az]; |

452 | }; |

453 | 1# -> |

454 | (#,#) [lvl8_r4Ao |

455 | lvl19_r4Az]; |

456 | }; |

457 | }; |

458 | }; |

459 | Unboxed.Node3 v_s4Cv [Occ=Once] |

460 | _ [Occ=Dead] |

461 | _ [Occ=Dead] |

462 | _ [Occ=Dead] -> |

463 | case v_s4Cv of { |

464 | GHC.Types.I# y1_s4CA [Occ=Once] -> |

465 | case |

466 | +# [x_s4Ck y1_s4CA] |

467 | of |

468 | sat_s4CB |

469 | { __DEFAULT -> |

470 | case |

471 | ># [sat_s4CB y_s4BN] |

472 | of |

473 | { __DEFAULT -> |

474 | case c1_s4Ch of { |

475 | __DEFAULT -> |

476 | (#,#) [lvl8_r4Ao |

477 | lvl19_r4Az]; |

478 | }; |

479 | 1# -> |

480 | (#,#) [lvl8_r4Ao |

481 | lvl19_r4Az]; |

482 | }; |

483 | }; |

484 | }; |

485 | }; |

486 | 1# -> (#,#) [lvl8_r4Ao lvl19_r4Az]; |

487 | }; |

488 | } in |

489 | case a_s4Cf of { |

490 | Unboxed.Node2 v_s4CF [Occ=Once] |

491 | _ [Occ=Dead] |

492 | _ [Occ=Dead] -> |

493 | case v_s4CF of { |

494 | GHC.Types.I# y1_s4CJ [Occ=Once] -> |

495 | case +# [w2_s4BL y1_s4CJ] of sat_s4CK { |

496 | __DEFAULT -> $j_s4Cj sat_s4CK; |

497 | }; |

498 | }; |

499 | Unboxed.Node3 v_s4CL [Occ=Once] |

500 | _ [Occ=Dead] |

501 | _ [Occ=Dead] |

502 | _ [Occ=Dead] -> |

503 | case v_s4CL of { |

504 | GHC.Types.I# y1_s4CQ [Occ=Once] -> |

505 | case +# [w2_s4BL y1_s4CQ] of sat_s4CR { |

506 | __DEFAULT -> $j_s4Cj sat_s4CR; |

507 | }; |

508 | }; |

509 | }; |

510 | }; |

511 | 1# -> |

512 | case pr_s4BH of { |

513 | Unboxed.One _ [Occ=Dead] -> (#,#) [Unboxed.Empty lvl19_r4Az]; |

514 | Unboxed.Two a_s4CU [Occ=Once!] _ [Occ=Dead] -> |

515 | case a_s4CU of { |

516 | Unboxed.Node2 v_s4CX [Occ=Once] |

517 | _ [Occ=Dead] |

518 | _ [Occ=Dead] -> |

519 | case v_s4CX of { |

520 | GHC.Types.I# y1_s4D1 [Occ=Once] -> |

521 | case ># [y1_s4D1 y_s4BN] of { |

522 | __DEFAULT -> (#,#) [lvl13_r4At lvl19_r4Az]; |

523 | 1# -> (#,#) [Unboxed.Empty lvl19_r4Az]; |

524 | }; |

525 | }; |

526 | Unboxed.Node3 v_s4D4 [Occ=Once] |

527 | _ [Occ=Dead] |

528 | _ [Occ=Dead] |

529 | _ [Occ=Dead] -> |

530 | case v_s4D4 of { |

531 | GHC.Types.I# y1_s4D9 [Occ=Once] -> |

532 | case ># [y1_s4D9 y_s4BN] of { |

533 | __DEFAULT -> (#,#) [lvl13_r4At lvl19_r4Az]; |

534 | 1# -> (#,#) [Unboxed.Empty lvl19_r4Az]; |

535 | }; |

536 | }; |

537 | }; |

538 | Unboxed.Three a_s4Dc [Occ=Once!] |

539 | b_s4Dd [Occ=Once!] |

540 | _ [Occ=Dead] -> |

541 | let-no-escape { |

542 | $j_s4Df [Occ=Once*!T[1], Dmd=<C(S),1*C1(U(U,U))>] |

543 | :: GHC.Prim.Int# |

544 | -> (# Unboxed.FingerTree |

545 | Unboxed.Size |

546 | (Unboxed.Node Unboxed.Size c_s45o), |

547 | Unboxed.FingerTree |

548 | Unboxed.Size |

549 | (Unboxed.Node Unboxed.Size c_s45o) #) |

550 | [LclId[JoinId(1)], |

551 | Arity=1, |

552 | Str=<S,U>, |

553 | Unf=OtherCon []] = |

554 | sat-only [y_s4BN b_s4Dd] \r [x_s4Dg] |

555 | case ># [x_s4Dg y_s4BN] of { |

556 | __DEFAULT -> |

557 | case b_s4Dd of { |

558 | Unboxed.Node2 v_s4Dj [Occ=Once] |

559 | _ [Occ=Dead] |

560 | _ [Occ=Dead] -> |

561 | case v_s4Dj of { |

562 | GHC.Types.I# y1_s4Dn [Occ=Once] -> |

563 | case |

564 | +# [x_s4Dg y1_s4Dn] |

565 | of |

566 | sat_s4Do |

567 | { __DEFAULT -> |

568 | case |

569 | ># [sat_s4Do y_s4BN] |

570 | of |

571 | { __DEFAULT -> |

572 | (#,#) [lvl13_r4At |

573 | lvl19_r4Az]; |

574 | 1# -> |

575 | (#,#) [lvl13_r4At |

576 | lvl19_r4Az]; |

577 | }; |

578 | }; |

579 | }; |

580 | Unboxed.Node3 v_s4Ds [Occ=Once] |

581 | _ [Occ=Dead] |

582 | _ [Occ=Dead] |

583 | _ [Occ=Dead] -> |

584 | case v_s4Ds of { |

585 | GHC.Types.I# y1_s4Dx [Occ=Once] -> |

586 | case |

587 | +# [x_s4Dg y1_s4Dx] |

588 | of |

589 | sat_s4Dy |

590 | { __DEFAULT -> |

591 | case |

592 | ># [sat_s4Dy y_s4BN] |

593 | of |

594 | { __DEFAULT -> |

595 | (#,#) [lvl13_r4At |

596 | lvl19_r4Az]; |

597 | 1# -> |

598 | (#,#) [lvl13_r4At |

599 | lvl19_r4Az]; |

600 | }; |

601 | }; |

602 | }; |

603 | }; |

604 | 1# -> (#,#) [Unboxed.Empty lvl19_r4Az]; |

605 | }; |

606 | } in |

607 | case a_s4Dc of { |

608 | Unboxed.Node2 v_s4DD [Occ=Once] |

609 | _ [Occ=Dead] |

610 | _ [Occ=Dead] -> |

611 | case v_s4DD of { |

612 | GHC.Types.I# y1_s4DH [Occ=Once] -> |

613 | $j_s4Df y1_s4DH; |

614 | }; |

615 | Unboxed.Node3 v_s4DI [Occ=Once] |

616 | _ [Occ=Dead] |

617 | _ [Occ=Dead] |

618 | _ [Occ=Dead] -> |

619 | case v_s4DI of { |

620 | GHC.Types.I# y1_s4DN [Occ=Once] -> |

621 | $j_s4Df y1_s4DN; |

622 | }; |

623 | }; |

624 | Unboxed.Four a_s4DO [Occ=Once!] |

625 | b_s4DP [Occ=Once!] |

626 | c1_s4DQ [Occ=Once!] |

627 | _ [Occ=Dead] -> |

628 | let-no-escape { |

629 | $j_s4DS [Occ=Once*!T[1], Dmd=<C(S),1*C1(U(U,U))>] |

630 | :: GHC.Prim.Int# |

631 | -> (# Unboxed.FingerTree |

632 | Unboxed.Size |

633 | (Unboxed.Node Unboxed.Size c_s45o), |

634 | Unboxed.FingerTree |

635 | Unboxed.Size |

636 | (Unboxed.Node Unboxed.Size c_s45o) #) |

637 | [LclId[JoinId(1)], |

638 | Arity=1, |

639 | Str=<S,U>, |

640 | Unf=OtherCon []] = |

641 | sat-only [y_s4BN b_s4DP c1_s4DQ] \r [x_s4DT] |

642 | case ># [x_s4DT y_s4BN] of { |

643 | __DEFAULT -> |

644 | let-no-escape { |

645 | $j1_s4DV [Occ=Once*!T[1], |

646 | Dmd=<C(S),1*C1(U(U,U))>] |

647 | :: GHC.Prim.Int# |

648 | -> (# Unboxed.FingerTree |

649 | Unboxed.Size |

650 | (Unboxed.Node |

651 | Unboxed.Size c_s45o), |

652 | Unboxed.FingerTree |

653 | Unboxed.Size |

654 | (Unboxed.Node |

655 | Unboxed.Size c_s45o) #) |

656 | [LclId[JoinId(1)], |

657 | Arity=1, |

658 | Str=<S,U>, |

659 | Unf=OtherCon []] = |

660 | sat-only [y_s4BN |

661 | c1_s4DQ] \r [x1_s4DW] |

662 | case ># [x1_s4DW y_s4BN] of { |

663 | __DEFAULT -> |

664 | case c1_s4DQ of { |

665 | Unboxed.Node2 v_s4DZ [Occ=Once] |

666 | _ [Occ=Dead] |

667 | _ [Occ=Dead] -> |

668 | case v_s4DZ of { |

669 | GHC.Types.I# y1_s4E3 [Occ=Once] -> |

670 | case |

671 | +# [x1_s4DW |

672 | y1_s4E3] |

673 | of |

674 | sat_s4E4 |

675 | { __DEFAULT -> |

676 | case |

677 | ># [sat_s4E4 |

678 | y_s4BN] |

679 | of |

680 | { __DEFAULT -> |

681 | (#,#) [lvl13_r4At |

682 | lvl19_r4Az]; |

683 | 1# -> |

684 | (#,#) [lvl13_r4At |

685 | lvl19_r4Az]; |

686 | }; |

687 | }; |

688 | }; |

689 | Unboxed.Node3 v_s4E8 [Occ=Once] |

690 | _ [Occ=Dead] |

691 | _ [Occ=Dead] |

692 | _ [Occ=Dead] -> |

693 | case v_s4E8 of { |

694 | GHC.Types.I# y1_s4Ed [Occ=Once] -> |

695 | case |

696 | +# [x1_s4DW |

697 | y1_s4Ed] |

698 | of |

699 | sat_s4Ee |

700 | { __DEFAULT -> |

701 | case |

702 | ># [sat_s4Ee |

703 | y_s4BN] |

704 | of |

705 | { __DEFAULT -> |

706 | (#,#) [lvl13_r4At |

707 | lvl19_r4Az]; |

708 | 1# -> |

709 | (#,#) [lvl13_r4At |

710 | lvl19_r4Az]; |

711 | }; |

712 | }; |

713 | }; |

714 | }; |

715 | 1# -> |

716 | (#,#) [lvl13_r4At |

717 | lvl19_r4Az]; |

718 | }; |

719 | } in |

720 | case b_s4DP of { |

721 | Unboxed.Node2 v_s4Ek [Occ=Once] |

722 | _ [Occ=Dead] |

723 | _ [Occ=Dead] -> |

724 | case v_s4Ek of { |

725 | GHC.Types.I# y1_s4Eo [Occ=Once] -> |

726 | case |

727 | +# [x_s4DT y1_s4Eo] |

728 | of |

729 | sat_s4Ep |

730 | { __DEFAULT -> |

731 | $j1_s4DV sat_s4Ep; |

732 | }; |

733 | }; |

734 | Unboxed.Node3 v_s4Eq [Occ=Once] |

735 | _ [Occ=Dead] |

736 | _ [Occ=Dead] |

737 | _ [Occ=Dead] -> |

738 | case v_s4Eq of { |

739 | GHC.Types.I# y1_s4Ev [Occ=Once] -> |

740 | case |

741 | +# [x_s4DT y1_s4Ev] |

742 | of |

743 | sat_s4Ew |

744 | { __DEFAULT -> |

745 | $j1_s4DV sat_s4Ew; |

746 | }; |

747 | }; |

748 | }; |

749 | 1# -> (#,#) [Unboxed.Empty lvl19_r4Az]; |

750 | }; |

751 | } in |

752 | case a_s4DO of { |

753 | Unboxed.Node2 v_s4Ey [Occ=Once] |

754 | _ [Occ=Dead] |

755 | _ [Occ=Dead] -> |

756 | case v_s4Ey of { |

757 | GHC.Types.I# y1_s4EC [Occ=Once] -> |

758 | $j_s4DS y1_s4EC; |

759 | }; |

760 | Unboxed.Node3 v_s4ED [Occ=Once] |

761 | _ [Occ=Dead] |

762 | _ [Occ=Dead] |

763 | _ [Occ=Dead] -> |

764 | case v_s4ED of { |

765 | GHC.Types.I# y1_s4EI [Occ=Once] -> |

766 | $j_s4DS y1_s4EI; |

767 | }; |

768 | }; |

769 | }; |

770 | }; |

771 | }; |

772 | } in |

773 | case pr_s4BH of { |

774 | Unboxed.One a_s4EK [Occ=Once!] -> |

775 | case a_s4EK of { |

776 | Unboxed.Node2 v_s4EM [Occ=Once] _ [Occ=Dead] _ [Occ=Dead] -> |

777 | case v_s4EM of { |

778 | GHC.Types.I# y_s4EQ [Occ=Once] -> $w$j_s4BK y_s4EQ; |

779 | }; |

780 | Unboxed.Node3 v_s4ER [Occ=Once] |

781 | _ [Occ=Dead] |

782 | _ [Occ=Dead] |

783 | _ [Occ=Dead] -> |

784 | case v_s4ER of { |

785 | GHC.Types.I# y_s4EW [Occ=Once] -> $w$j_s4BK y_s4EW; |

786 | }; |

787 | }; |

788 | Unboxed.Two a_s4EX [Occ=Once!] b_s4EY [Occ=Once*!] -> |

789 | case a_s4EX of { |

790 | Unboxed.Node2 v_s4F0 [Occ=Once] _ [Occ=Dead] _ [Occ=Dead] -> |

791 | case v_s4F0 of { |

792 | GHC.Types.I# x_s4F4 [Occ=Once*] -> |

793 | case b_s4EY of { |

794 | Unboxed.Node2 v1_s4F6 [Occ=Once] _ [Occ=Dead] _ [Occ=Dead] -> |

795 | case v1_s4F6 of { |

796 | GHC.Types.I# y_s4Fa [Occ=Once] -> |

797 | case +# [x_s4F4 y_s4Fa] of sat_s4Fb { |

798 | __DEFAULT -> $w$j_s4BK sat_s4Fb; |

799 | }; |

800 | }; |

801 | Unboxed.Node3 v1_s4Fc [Occ=Once] |

802 | _ [Occ=Dead] |

803 | _ [Occ=Dead] |

804 | _ [Occ=Dead] -> |

805 | case v1_s4Fc of { |

806 | GHC.Types.I# y_s4Fh [Occ=Once] -> |

807 | case +# [x_s4F4 y_s4Fh] of sat_s4Fi { |

808 | __DEFAULT -> $w$j_s4BK sat_s4Fi; |

809 | }; |

810 | }; |

811 | }; |

812 | }; |

813 | Unboxed.Node3 v_s4Fj [Occ=Once] |

814 | _ [Occ=Dead] |

815 | _ [Occ=Dead] |

816 | _ [Occ=Dead] -> |

817 | case v_s4Fj of { |

818 | GHC.Types.I# x_s4Fo [Occ=Once*] -> |

819 | case b_s4EY of { |

820 | Unboxed.Node2 v1_s4Fq [Occ=Once] _ [Occ=Dead] _ [Occ=Dead] -> |

821 | case v1_s4Fq of { |

822 | GHC.Types.I# y_s4Fu [Occ=Once] -> |

823 | case +# [x_s4Fo y_s4Fu] of sat_s4Fv { |

824 | __DEFAULT -> $w$j_s4BK sat_s4Fv; |

825 | }; |

826 | }; |

827 | Unboxed.Node3 v1_s4Fw [Occ=Once] |

828 | _ [Occ=Dead] |

829 | _ [Occ=Dead] |

830 | _ [Occ=Dead] -> |

831 | case v1_s4Fw of { |

832 | GHC.Types.I# y_s4FB [Occ=Once] -> |

833 | case +# [x_s4Fo y_s4FB] of sat_s4FC { |

834 | __DEFAULT -> $w$j_s4BK sat_s4FC; |

835 | }; |

836 | }; |

837 | }; |

838 | }; |

839 | }; |

840 | Unboxed.Three a_s4FD [Occ=Once!] |

841 | b_s4FE [Occ=Once!] |

842 | c1_s4FF [Occ=Once*!] -> |

843 | let-no-escape { |

844 | $j_s4FG [Occ=Once*!T[1], Dmd=<C(S),1*C1(U(U,U))>] |

845 | :: GHC.Prim.Int# |

846 | -> (# Unboxed.FingerTree |

847 | Unboxed.Size (Unboxed.Node Unboxed.Size c_s45o), |

848 | Unboxed.FingerTree |

849 | Unboxed.Size (Unboxed.Node Unboxed.Size c_s45o) #) |

850 | [LclId[JoinId(1)], Arity=1, Str=<S,U>, Unf=OtherCon []] = |

851 | sat-only [$w$j_s4BK b_s4FE c1_s4FF] \r [x_s4FH] |

852 | case b_s4FE of { |

853 | Unboxed.Node2 v_s4FJ [Occ=Once] _ [Occ=Dead] _ [Occ=Dead] -> |

854 | case v_s4FJ of { |

855 | GHC.Types.I# y_s4FN [Occ=Once*] -> |

856 | case c1_s4FF of { |

857 | Unboxed.Node2 v1_s4FP [Occ=Once] |

858 | _ [Occ=Dead] |

859 | _ [Occ=Dead] -> |

860 | case v1_s4FP of { |

861 | GHC.Types.I# y1_s4FT [Occ=Once] -> |

862 | case +# [x_s4FH y_s4FN] of sat_s4FU { |

863 | __DEFAULT -> |

864 | case |

865 | +# [sat_s4FU y1_s4FT] |

866 | of |

867 | sat_s4FV |

868 | { __DEFAULT -> $w$j_s4BK sat_s4FV; |

869 | }; |

870 | }; |

871 | }; |

872 | Unboxed.Node3 v1_s4FW [Occ=Once] |

873 | _ [Occ=Dead] |

874 | _ [Occ=Dead] |

875 | _ [Occ=Dead] -> |

876 | case v1_s4FW of { |

877 | GHC.Types.I# y1_s4G1 [Occ=Once] -> |

878 | case +# [x_s4FH y_s4FN] of sat_s4G2 { |

879 | __DEFAULT -> |

880 | case |

881 | +# [sat_s4G2 y1_s4G1] |

882 | of |

883 | sat_s4G3 |

884 | { __DEFAULT -> $w$j_s4BK sat_s4G3; |

885 | }; |

886 | }; |

887 | }; |

888 | }; |

889 | }; |

890 | Unboxed.Node3 v_s4G4 [Occ=Once] |

891 | _ [Occ=Dead] |

892 | _ [Occ=Dead] |

893 | _ [Occ=Dead] -> |

894 | case v_s4G4 of { |

895 | GHC.Types.I# y_s4G9 [Occ=Once*] -> |

896 | case c1_s4FF of { |

897 | Unboxed.Node2 v1_s4Gb [Occ=Once] |

898 | _ [Occ=Dead] |

899 | _ [Occ=Dead] -> |

900 | case v1_s4Gb of { |

901 | GHC.Types.I# y1_s4Gf [Occ=Once] -> |

902 | case +# [x_s4FH y_s4G9] of sat_s4Gg { |

903 | __DEFAULT -> |

904 | case |

905 | +# [sat_s4Gg y1_s4Gf] |

906 | of |

907 | sat_s4Gh |

908 | { __DEFAULT -> $w$j_s4BK sat_s4Gh; |

909 | }; |

910 | }; |

911 | }; |

912 | Unboxed.Node3 v1_s4Gi [Occ=Once] |

913 | _ [Occ=Dead] |

914 | _ [Occ=Dead] |

915 | _ [Occ=Dead] -> |

916 | case v1_s4Gi of { |

917 | GHC.Types.I# y1_s4Gn [Occ=Once] -> |

918 | case +# [x_s4FH y_s4G9] of sat_s4Go { |

919 | __DEFAULT -> |

920 | case |

921 | +# [sat_s4Go y1_s4Gn] |

922 | of |

923 | sat_s4Gp |

924 | { __DEFAULT -> $w$j_s4BK sat_s4Gp; |

925 | }; |

926 | }; |

927 | }; |

928 | }; |

929 | }; |

930 | }; |

931 | } in |

932 | case a_s4FD of { |

933 | Unboxed.Node2 v_s4Gr [Occ=Once] _ [Occ=Dead] _ [Occ=Dead] -> |

934 | case v_s4Gr of { |

935 | GHC.Types.I# x_s4Gv [Occ=Once] -> $j_s4FG x_s4Gv; |

936 | }; |

937 | Unboxed.Node3 v_s4Gw [Occ=Once] |

938 | _ [Occ=Dead] |

939 | _ [Occ=Dead] |

940 | _ [Occ=Dead] -> |

941 | case v_s4Gw of { |

942 | GHC.Types.I# x_s4GB [Occ=Once] -> $j_s4FG x_s4GB; |

943 | }; |

944 | }; |

945 | Unboxed.Four a_s4GC [Occ=Once!] |

946 | b_s4GD [Occ=Once!] |

947 | c1_s4GE [Occ=Once!] |

948 | d_s4GF [Occ=Once*!] -> |

949 | let-no-escape { |

950 | $j_s4GG [Occ=Once*!T[1], Dmd=<C(S),1*C1(U(U,U))>] |

951 | :: GHC.Prim.Int# |

952 | -> (# Unboxed.FingerTree |

953 | Unboxed.Size (Unboxed.Node Unboxed.Size c_s45o), |

954 | Unboxed.FingerTree |

955 | Unboxed.Size (Unboxed.Node Unboxed.Size c_s45o) #) |

956 | [LclId[JoinId(1)], Arity=1, Str=<S,U>, Unf=OtherCon []] = |

957 | sat-only [$w$j_s4BK b_s4GD c1_s4GE d_s4GF] \r [x_s4GH] |

958 | let-no-escape { |

959 | $j1_s4GI [Occ=Once*!T[1], Dmd=<C(S),1*C1(U(U,U))>] |

960 | :: GHC.Prim.Int# |

961 | -> (# Unboxed.FingerTree |

962 | Unboxed.Size (Unboxed.Node Unboxed.Size c_s45o), |

963 | Unboxed.FingerTree |

964 | Unboxed.Size (Unboxed.Node Unboxed.Size c_s45o) #) |

965 | [LclId[JoinId(1)], Arity=1, Str=<S,U>, Unf=OtherCon []] = |

966 | sat-only [$w$j_s4BK c1_s4GE d_s4GF x_s4GH] \r [y_s4GJ] |

967 | case c1_s4GE of { |

968 | Unboxed.Node2 v_s4GL [Occ=Once] |

969 | _ [Occ=Dead] |

970 | _ [Occ=Dead] -> |

971 | case v_s4GL of { |

972 | GHC.Types.I# y1_s4GP [Occ=Once*] -> |

973 | case d_s4GF of { |

974 | Unboxed.Node2 v1_s4GR [Occ=Once] |

975 | _ [Occ=Dead] |

976 | _ [Occ=Dead] -> |

977 | case v1_s4GR of { |

978 | GHC.Types.I# y2_s4GV [Occ=Once] -> |

979 | case |

980 | +# [x_s4GH y_s4GJ] |

981 | of |

982 | sat_s4GW |

983 | { __DEFAULT -> |

984 | case |

985 | +# [sat_s4GW y1_s4GP] |

986 | of |

987 | sat_s4GX |

988 | { __DEFAULT -> |

989 | case |

990 | +# [sat_s4GX |

991 | y2_s4GV] |

992 | of |

993 | sat_s4GY |

994 | { __DEFAULT -> |

995 | $w$j_s4BK |

996 | sat_s4GY; |

997 | }; |

998 | }; |

999 | }; |

1000 | }; |

1001 | Unboxed.Node3 v1_s4GZ [Occ=Once] |

1002 | _ [Occ=Dead] |

1003 | _ [Occ=Dead] |

1004 | _ [Occ=Dead] -> |

1005 | case v1_s4GZ of { |

1006 | GHC.Types.I# y2_s4H4 [Occ=Once] -> |

1007 | case |

1008 | +# [x_s4GH y_s4GJ] |

1009 | of |

1010 | sat_s4H5 |

1011 | { __DEFAULT -> |

1012 | case |

1013 | +# [sat_s4H5 y1_s4GP] |

1014 | of |

1015 | sat_s4H6 |

1016 | { __DEFAULT -> |

1017 | case |

1018 | +# [sat_s4H6 |

1019 | y2_s4H4] |

1020 | of |

1021 | sat_s4H7 |

1022 | { __DEFAULT -> |

1023 | $w$j_s4BK |

1024 | sat_s4H7; |

1025 | }; |

1026 | }; |

1027 | }; |

1028 | }; |

1029 | }; |

1030 | }; |

1031 | Unboxed.Node3 v_s4H8 [Occ=Once] |

1032 | _ [Occ=Dead] |

1033 | _ [Occ=Dead] |

1034 | _ [Occ=Dead] -> |

1035 | case v_s4H8 of { |

1036 | GHC.Types.I# y1_s4Hd [Occ=Once*] -> |

1037 | case d_s4GF of { |

1038 | Unboxed.Node2 v1_s4Hf [Occ=Once] |

1039 | _ [Occ=Dead] |

1040 | _ [Occ=Dead] -> |

1041 | case v1_s4Hf of { |

1042 | GHC.Types.I# y2_s4Hj [Occ=Once] -> |

1043 | case |

1044 | +# [x_s4GH y_s4GJ] |

1045 | of |

1046 | sat_s4Hk |

1047 | { __DEFAULT -> |

1048 | case |

1049 | +# [sat_s4Hk y1_s4Hd] |

1050 | of |

1051 | sat_s4Hl |

1052 | { __DEFAULT -> |

1053 | case |

1054 | +# [sat_s4Hl |

1055 | y2_s4Hj] |

1056 | of |

1057 | sat_s4Hm |

1058 | { __DEFAULT -> |

1059 | $w$j_s4BK |

1060 | sat_s4Hm; |

1061 | }; |

1062 | }; |

1063 | }; |

1064 | }; |

1065 | Unboxed.Node3 v1_s4Hn [Occ=Once] |

1066 | _ [Occ=Dead] |

1067 | _ [Occ=Dead] |

1068 | _ [Occ=Dead] -> |

1069 | case v1_s4Hn of { |

1070 | GHC.Types.I# y2_s4Hs [Occ=Once] -> |

1071 | case |

1072 | +# [x_s4GH y_s4GJ] |

1073 | of |

1074 | sat_s4Ht |

1075 | { __DEFAULT -> |

1076 | case |

1077 | +# [sat_s4Ht y1_s4Hd] |

1078 | of |

1079 | sat_s4Hu |

1080 | { __DEFAULT -> |

1081 | case |

1082 | +# [sat_s4Hu |

1083 | y2_s4Hs] |

1084 | of |

1085 | sat_s4Hv |

1086 | { __DEFAULT -> |

1087 | $w$j_s4BK |

1088 | sat_s4Hv; |

1089 | }; |

1090 | }; |

1091 | }; |

1092 | }; |

1093 | }; |

1094 | }; |

1095 | }; |

1096 | } in |

1097 | case b_s4GD of { |

1098 | Unboxed.Node2 v_s4Hx [Occ=Once] _ [Occ=Dead] _ [Occ=Dead] -> |

1099 | case v_s4Hx of { |

1100 | GHC.Types.I# y_s4HB [Occ=Once] -> $j1_s4GI y_s4HB; |

1101 | }; |

1102 | Unboxed.Node3 v_s4HC [Occ=Once] |

1103 | _ [Occ=Dead] |

1104 | _ [Occ=Dead] |

1105 | _ [Occ=Dead] -> |

1106 | case v_s4HC of { |

1107 | GHC.Types.I# y_s4HH [Occ=Once] -> $j1_s4GI y_s4HH; |

1108 | }; |

1109 | }; |

1110 | } in |

1111 | case a_s4GC of { |

1112 | Unboxed.Node2 v_s4HJ [Occ=Once] _ [Occ=Dead] _ [Occ=Dead] -> |

1113 | case v_s4HJ of { |

1114 | GHC.Types.I# x_s4HN [Occ=Once] -> $j_s4GG x_s4HN; |

1115 | }; |

1116 | Unboxed.Node3 v_s4HO [Occ=Once] |

1117 | _ [Occ=Dead] |

1118 | _ [Occ=Dead] |

1119 | _ [Occ=Dead] -> |

1120 | case v_s4HO of { |

1121 | GHC.Types.I# x_s4HT [Occ=Once] -> $j_s4GG x_s4HT; |

1122 | }; |

1123 | }; |

1124 | }; |

1125 | }; |

1126 | |

1127 | Unboxed.mySplit [InlPrag=NOUSERINLINE[0]] |

1128 | :: forall c. |

1129 | GHC.Types.Int |

1130 | -> Unboxed.FingerTree Unboxed.Size (Unboxed.Node Unboxed.Size c) |

1131 | -> (Unboxed.FingerTree Unboxed.Size (Unboxed.Node Unboxed.Size c), |

1132 | Unboxed.FingerTree Unboxed.Size (Unboxed.Node Unboxed.Size c)) |

1133 | [GblId, Arity=2, Str=<L,1*U(U)><S,1*U>m, Unf=OtherCon []] = |

1134 | [] \r [w_s4HU w1_s4HV] |

1135 | case Unboxed.$wmySplit w_s4HU w1_s4HV of { |

1136 | (#,#) ww1_s4HX [Occ=Once] ww2_s4HY [Occ=Once] -> |

1137 | (,) [ww1_s4HX ww2_s4HY]; |

1138 | }; |

1139 | |

1140 | Unboxed.$trModule3 :: GHC.Types.TrName |

1141 | [GblId, Caf=NoCafRefs, Str=m1, Unf=OtherCon []] = |

1142 | CCS_DONT_CARE GHC.Types.TrNameS! [Unboxed.$trModule4]; |

1143 | |

1144 | Unboxed.$trModule1 :: GHC.Types.TrName |

1145 | [GblId, Caf=NoCafRefs, Str=m1, Unf=OtherCon []] = |

1146 | CCS_DONT_CARE GHC.Types.TrNameS! [Unboxed.$trModule2]; |

1147 | |

1148 | Unboxed.$trModule :: GHC.Types.Module |

1149 | [GblId, Caf=NoCafRefs, Str=m, Unf=OtherCon []] = |

1150 | CCS_DONT_CARE GHC.Types.Module! [Unboxed.$trModule3 |

1151 | Unboxed.$trModule1]; |

1152 | |

1153 | $krep_r4AA :: GHC.Types.KindRep |

1154 | [GblId, Caf=NoCafRefs, Str=m1, Unf=OtherCon []] = |

1155 | CCS_DONT_CARE GHC.Types.KindRepTyConApp! [GHC.Types.$tcInt |

1156 | GHC.Types.[]]; |

1157 | |

1158 | $krep1_r4AB :: GHC.Types.KindRep |

1159 | [GblId, Caf=NoCafRefs, Str=m2, Unf=OtherCon []] = |

1160 | CCS_DONT_CARE GHC.Types.KindRepVar! [1#]; |

1161 | |

1162 | $krep2_r4AC :: GHC.Types.KindRep |

1163 | [GblId, Caf=NoCafRefs, Str=m2, Unf=OtherCon []] = |

1164 | CCS_DONT_CARE GHC.Types.KindRepVar! [0#]; |

1165 | |

1166 | Unboxed.$tcDigit2 :: GHC.Prim.Addr# |

1167 | [GblId, Caf=NoCafRefs, Unf=OtherCon []] = |

1168 | "Digit"#; |

1169 | |

1170 | Unboxed.$tcDigit1 :: GHC.Types.TrName |

1171 | [GblId, Caf=NoCafRefs, Str=m1, Unf=OtherCon []] = |

1172 | CCS_DONT_CARE GHC.Types.TrNameS! [Unboxed.$tcDigit2]; |

1173 | |

1174 | Unboxed.$tcDigit :: GHC.Types.TyCon |

1175 | [GblId, Caf=NoCafRefs, Str=m, Unf=OtherCon []] = |

1176 | CCS_DONT_CARE GHC.Types.TyCon! [14636189114014665057## |

1177 | 3244156513758390385## |

1178 | Unboxed.$trModule |

1179 | Unboxed.$tcDigit1 |

1180 | 0# |

1181 | GHC.Types.krep$*Arr*]; |

1182 | |

1183 | $krep3_r4AD :: [GHC.Types.KindRep] |

1184 | [GblId, Caf=NoCafRefs, Str=m2, Unf=OtherCon []] = |

1185 | CCS_DONT_CARE :! [$krep2_r4AC GHC.Types.[]]; |

1186 | |

1187 | $krep4_r4AE :: GHC.Types.KindRep |

1188 | [GblId, Caf=NoCafRefs, Str=m1, Unf=OtherCon []] = |

1189 | CCS_DONT_CARE GHC.Types.KindRepTyConApp! [Unboxed.$tcDigit |

1190 | $krep3_r4AD]; |

1191 | |

1192 | Unboxed.$tc'One1 [InlPrag=NOUSERINLINE[~]] :: GHC.Types.KindRep |

1193 | [GblId, Caf=NoCafRefs, Str=m4, Unf=OtherCon []] = |

1194 | CCS_DONT_CARE GHC.Types.KindRepFun! [$krep2_r4AC $krep4_r4AE]; |

1195 | |

1196 | Unboxed.$tc'One3 :: GHC.Prim.Addr# |

1197 | [GblId, Caf=NoCafRefs, Unf=OtherCon []] = |

1198 | "'One"#; |

1199 | |

1200 | Unboxed.$tc'One2 :: GHC.Types.TrName |

1201 | [GblId, Caf=NoCafRefs, Str=m1, Unf=OtherCon []] = |

1202 | CCS_DONT_CARE GHC.Types.TrNameS! [Unboxed.$tc'One3]; |

1203 | |

1204 | Unboxed.$tc'One :: GHC.Types.TyCon |

1205 | [GblId, Caf=NoCafRefs, Str=m, Unf=OtherCon []] = |

1206 | CCS_DONT_CARE GHC.Types.TyCon! [13145429465336945561## |

1207 | 1951529563298898057## |

1208 | Unboxed.$trModule |

1209 | Unboxed.$tc'One2 |

1210 | 1# |

1211 | Unboxed.$tc'One1]; |

1212 | |

1213 | Unboxed.$tc'Two1 [InlPrag=NOUSERINLINE[~]] :: GHC.Types.KindRep |

1214 | [GblId, Caf=NoCafRefs, Str=m4, Unf=OtherCon []] = |

1215 | CCS_DONT_CARE GHC.Types.KindRepFun! [$krep2_r4AC Unboxed.$tc'One1]; |

1216 | |

1217 | Unboxed.$tc'Two3 :: GHC.Prim.Addr# |

1218 | [GblId, Caf=NoCafRefs, Unf=OtherCon []] = |

1219 | "'Two"#; |

1220 | |

1221 | Unboxed.$tc'Two2 :: GHC.Types.TrName |

1222 | [GblId, Caf=NoCafRefs, Str=m1, Unf=OtherCon []] = |

1223 | CCS_DONT_CARE GHC.Types.TrNameS! [Unboxed.$tc'Two3]; |

1224 | |

1225 | Unboxed.$tc'Two :: GHC.Types.TyCon |

1226 | [GblId, Caf=NoCafRefs, Str=m, Unf=OtherCon []] = |

1227 | CCS_DONT_CARE GHC.Types.TyCon! [3245166009349240472## |

1228 | 15678821682105395784## |

1229 | Unboxed.$trModule |

1230 | Unboxed.$tc'Two2 |

1231 | 1# |

1232 | Unboxed.$tc'Two1]; |

1233 | |

1234 | Unboxed.$tc'Three1 [InlPrag=NOUSERINLINE[~]] :: GHC.Types.KindRep |

1235 | [GblId, Caf=NoCafRefs, Str=m4, Unf=OtherCon []] = |

1236 | CCS_DONT_CARE GHC.Types.KindRepFun! [$krep2_r4AC Unboxed.$tc'Two1]; |

1237 | |

1238 | Unboxed.$tc'Three3 :: GHC.Prim.Addr# |

1239 | [GblId, Caf=NoCafRefs, Unf=OtherCon []] = |

1240 | "'Three"#; |

1241 | |

1242 | Unboxed.$tc'Three2 :: GHC.Types.TrName |

1243 | [GblId, Caf=NoCafRefs, Str=m1, Unf=OtherCon []] = |

1244 | CCS_DONT_CARE GHC.Types.TrNameS! [Unboxed.$tc'Three3]; |

1245 | |

1246 | Unboxed.$tc'Three :: GHC.Types.TyCon |

1247 | [GblId, Caf=NoCafRefs, Str=m, Unf=OtherCon []] = |

1248 | CCS_DONT_CARE GHC.Types.TyCon! [10539477579313313060## |

1249 | 9287867415363315468## |

1250 | Unboxed.$trModule |

1251 | Unboxed.$tc'Three2 |

1252 | 1# |

1253 | Unboxed.$tc'Three1]; |

1254 | |

1255 | Unboxed.$tc'Four1 [InlPrag=NOUSERINLINE[~]] :: GHC.Types.KindRep |

1256 | [GblId, Caf=NoCafRefs, Str=m4, Unf=OtherCon []] = |

1257 | CCS_DONT_CARE GHC.Types.KindRepFun! [$krep2_r4AC |

1258 | Unboxed.$tc'Three1]; |

1259 | |

1260 | Unboxed.$tc'Four3 :: GHC.Prim.Addr# |

1261 | [GblId, Caf=NoCafRefs, Unf=OtherCon []] = |

1262 | "'Four"#; |

1263 | |

1264 | Unboxed.$tc'Four2 :: GHC.Types.TrName |

1265 | [GblId, Caf=NoCafRefs, Str=m1, Unf=OtherCon []] = |

1266 | CCS_DONT_CARE GHC.Types.TrNameS! [Unboxed.$tc'Four3]; |

1267 | |

1268 | Unboxed.$tc'Four :: GHC.Types.TyCon |

1269 | [GblId, Caf=NoCafRefs, Str=m, Unf=OtherCon []] = |

1270 | CCS_DONT_CARE GHC.Types.TyCon! [8412709199749071934## |

1271 | 1780562435450824923## |

1272 | Unboxed.$trModule |

1273 | Unboxed.$tc'Four2 |

1274 | 1# |

1275 | Unboxed.$tc'Four1]; |

1276 | |

1277 | $krep5_r4AF :: [GHC.Types.KindRep] |

1278 | [GblId, Caf=NoCafRefs, Str=m2, Unf=OtherCon []] = |

1279 | CCS_DONT_CARE :! [$krep1_r4AB GHC.Types.[]]; |

1280 | |

1281 | $krep6_r4AG :: GHC.Types.KindRep |

1282 | [GblId, Caf=NoCafRefs, Str=m1, Unf=OtherCon []] = |

1283 | CCS_DONT_CARE GHC.Types.KindRepTyConApp! [Unboxed.$tcDigit |

1284 | $krep5_r4AF]; |

1285 | |

1286 | Unboxed.$tcNode2 :: GHC.Prim.Addr# |

1287 | [GblId, Caf=NoCafRefs, Unf=OtherCon []] = |

1288 | "Node"#; |

1289 | |

1290 | Unboxed.$tcNode1 :: GHC.Types.TrName |

1291 | [GblId, Caf=NoCafRefs, Str=m1, Unf=OtherCon []] = |

1292 | CCS_DONT_CARE GHC.Types.TrNameS! [Unboxed.$tcNode2]; |

1293 | |

1294 | Unboxed.$tcNode :: GHC.Types.TyCon |

1295 | [GblId, Caf=NoCafRefs, Str=m, Unf=OtherCon []] = |

1296 | CCS_DONT_CARE GHC.Types.TyCon! [14310021920068471419## |

1297 | 7752484679340451626## |

1298 | Unboxed.$trModule |

1299 | Unboxed.$tcNode1 |

1300 | 0# |

1301 | GHC.Types.krep$*->*->*]; |

1302 | |

1303 | $krep7_r4AH :: [GHC.Types.KindRep] |

1304 | [GblId, Caf=NoCafRefs, Str=m2, Unf=OtherCon []] = |

1305 | CCS_DONT_CARE :! [$krep2_r4AC $krep5_r4AF]; |

1306 | |

1307 | $krep8_r4AI :: GHC.Types.KindRep |

1308 | [GblId, Caf=NoCafRefs, Str=m1, Unf=OtherCon []] = |

1309 | CCS_DONT_CARE GHC.Types.KindRepTyConApp! [Unboxed.$tcNode |

1310 | $krep7_r4AH]; |

1311 | |

1312 | $krep9_r4AJ :: GHC.Types.KindRep |

1313 | [GblId, Caf=NoCafRefs, Str=m4, Unf=OtherCon []] = |

1314 | CCS_DONT_CARE GHC.Types.KindRepFun! [$krep1_r4AB $krep8_r4AI]; |

1315 | |

1316 | $krep10_r4AK :: GHC.Types.KindRep |

1317 | [GblId, Caf=NoCafRefs, Str=m4, Unf=OtherCon []] = |

1318 | CCS_DONT_CARE GHC.Types.KindRepFun! [$krep1_r4AB $krep9_r4AJ]; |

1319 | |

1320 | Unboxed.$tc'Node1 [InlPrag=NOUSERINLINE[~]] :: GHC.Types.KindRep |

1321 | [GblId, Caf=NoCafRefs, Str=m4, Unf=OtherCon []] = |

1322 | CCS_DONT_CARE GHC.Types.KindRepFun! [$krep2_r4AC $krep10_r4AK]; |

1323 | |

1324 | Unboxed.$tc'Node6 :: GHC.Prim.Addr# |

1325 | [GblId, Caf=NoCafRefs, Unf=OtherCon []] = |

1326 | "'Node2"#; |

1327 | |

1328 | Unboxed.$tc'Node5 :: GHC.Types.TrName |

1329 | [GblId, Caf=NoCafRefs, Str=m1, Unf=OtherCon []] = |

1330 | CCS_DONT_CARE GHC.Types.TrNameS! [Unboxed.$tc'Node6]; |

1331 | |

1332 | Unboxed.$tc'Node2 :: GHC.Types.TyCon |

1333 | [GblId, Caf=NoCafRefs, Str=m, Unf=OtherCon []] = |

1334 | CCS_DONT_CARE GHC.Types.TyCon! [16188463194491579684## |

1335 | 8521110775579450636## |

1336 | Unboxed.$trModule |

1337 | Unboxed.$tc'Node5 |

1338 | 2# |

1339 | Unboxed.$tc'Node1]; |

1340 | |

1341 | $krep11_r4AL :: GHC.Types.KindRep |

1342 | [GblId, Caf=NoCafRefs, Str=m4, Unf=OtherCon []] = |

1343 | CCS_DONT_CARE GHC.Types.KindRepFun! [$krep1_r4AB $krep10_r4AK]; |

1344 | |

1345 | Unboxed.$tc'Node7 [InlPrag=NOUSERINLINE[~]] :: GHC.Types.KindRep |

1346 | [GblId, Caf=NoCafRefs, Str=m4, Unf=OtherCon []] = |

1347 | CCS_DONT_CARE GHC.Types.KindRepFun! [$krep2_r4AC $krep11_r4AL]; |

1348 | |

1349 | Unboxed.$tc'Node9 :: GHC.Prim.Addr# |

1350 | [GblId, Caf=NoCafRefs, Unf=OtherCon []] = |

1351 | "'Node3"#; |

1352 | |

1353 | Unboxed.$tc'Node8 :: GHC.Types.TrName |

1354 | [GblId, Caf=NoCafRefs, Str=m1, Unf=OtherCon []] = |

1355 | CCS_DONT_CARE GHC.Types.TrNameS! [Unboxed.$tc'Node9]; |

1356 | |

1357 | Unboxed.$tc'Node3 :: GHC.Types.TyCon |

1358 | [GblId, Caf=NoCafRefs, Str=m, Unf=OtherCon []] = |

1359 | CCS_DONT_CARE GHC.Types.TyCon! [5824654492323244063## |

1360 | 13374226018913758109## |

1361 | Unboxed.$trModule |

1362 | Unboxed.$tc'Node8 |

1363 | 2# |

1364 | Unboxed.$tc'Node7]; |

1365 | |

1366 | Unboxed.$tcFingerTree2 :: GHC.Prim.Addr# |

1367 | [GblId, Caf=NoCafRefs, Unf=OtherCon []] = |

1368 | "FingerTree"#; |

1369 | |

1370 | Unboxed.$tcFingerTree1 :: GHC.Types.TrName |

1371 | [GblId, Caf=NoCafRefs, Str=m1, Unf=OtherCon []] = |

1372 | CCS_DONT_CARE GHC.Types.TrNameS! [Unboxed.$tcFingerTree2]; |

1373 | |

1374 | Unboxed.$tcFingerTree :: GHC.Types.TyCon |

1375 | [GblId, Caf=NoCafRefs, Str=m, Unf=OtherCon []] = |

1376 | CCS_DONT_CARE GHC.Types.TyCon! [16822976935429065404## |

1377 | 1656303194987393222## |

1378 | Unboxed.$trModule |

1379 | Unboxed.$tcFingerTree1 |

1380 | 0# |

1381 | GHC.Types.krep$*->*->*]; |

1382 | |

1383 | Unboxed.$tc'Empty1 [InlPrag=NOUSERINLINE[~]] :: GHC.Types.KindRep |

1384 | [GblId, Caf=NoCafRefs, Str=m1, Unf=OtherCon []] = |

1385 | CCS_DONT_CARE GHC.Types.KindRepTyConApp! [Unboxed.$tcFingerTree |

1386 | $krep7_r4AH]; |

1387 | |

1388 | Unboxed.$tc'Empty3 :: GHC.Prim.Addr# |

1389 | [GblId, Caf=NoCafRefs, Unf=OtherCon []] = |

1390 | "'Empty"#; |

1391 | |

1392 | Unboxed.$tc'Empty2 :: GHC.Types.TrName |

1393 | [GblId, Caf=NoCafRefs, Str=m1, Unf=OtherCon []] = |

1394 | CCS_DONT_CARE GHC.Types.TrNameS! [Unboxed.$tc'Empty3]; |

1395 | |

1396 | Unboxed.$tc'Empty :: GHC.Types.TyCon |

1397 | [GblId, Caf=NoCafRefs, Str=m, Unf=OtherCon []] = |

1398 | CCS_DONT_CARE GHC.Types.TyCon! [8016004449277268857## |

1399 | 8175871094911629858## |

1400 | Unboxed.$trModule |

1401 | Unboxed.$tc'Empty2 |

1402 | 2# |

1403 | Unboxed.$tc'Empty1]; |

1404 | |

1405 | Unboxed.$tc'Single1 [InlPrag=NOUSERINLINE[~]] :: GHC.Types.KindRep |

1406 | [GblId, Caf=NoCafRefs, Str=m4, Unf=OtherCon []] = |

1407 | CCS_DONT_CARE GHC.Types.KindRepFun! [$krep1_r4AB |

1408 | Unboxed.$tc'Empty1]; |

1409 | |

1410 | Unboxed.$tc'Single3 :: GHC.Prim.Addr# |

1411 | [GblId, Caf=NoCafRefs, Unf=OtherCon []] = |

1412 | "'Single"#; |

1413 | |

1414 | Unboxed.$tc'Single2 :: GHC.Types.TrName |

1415 | [GblId, Caf=NoCafRefs, Str=m1, Unf=OtherCon []] = |

1416 | CCS_DONT_CARE GHC.Types.TrNameS! [Unboxed.$tc'Single3]; |

1417 | |

1418 | Unboxed.$tc'Single :: GHC.Types.TyCon |

1419 | [GblId, Caf=NoCafRefs, Str=m, Unf=OtherCon []] = |

1420 | CCS_DONT_CARE GHC.Types.TyCon! [690857965741511270## |

1421 | 16411512555119301998## |

1422 | Unboxed.$trModule |

1423 | Unboxed.$tc'Single2 |

1424 | 2# |

1425 | Unboxed.$tc'Single1]; |

1426 | |

1427 | $krep12_r4AM :: GHC.Types.KindRep |

1428 | [GblId, Caf=NoCafRefs, Str=m4, Unf=OtherCon []] = |

1429 | CCS_DONT_CARE GHC.Types.KindRepFun! [$krep6_r4AG |

1430 | Unboxed.$tc'Empty1]; |

1431 | |

1432 | $krep13_r4AN :: [GHC.Types.KindRep] |

1433 | [GblId, Caf=NoCafRefs, Str=m2, Unf=OtherCon []] = |

1434 | CCS_DONT_CARE :! [$krep8_r4AI GHC.Types.[]]; |

1435 | |

1436 | $krep14_r4AO :: [GHC.Types.KindRep] |

1437 | [GblId, Caf=NoCafRefs, Str=m2, Unf=OtherCon []] = |

1438 | CCS_DONT_CARE :! [$krep2_r4AC $krep13_r4AN]; |

1439 | |

1440 | $krep15_r4AP :: GHC.Types.KindRep |

1441 | [GblId, Caf=NoCafRefs, Str=m1, Unf=OtherCon []] = |

1442 | CCS_DONT_CARE GHC.Types.KindRepTyConApp! [Unboxed.$tcFingerTree |

1443 | $krep14_r4AO]; |

1444 | |

1445 | $krep16_r4AQ :: GHC.Types.KindRep |

1446 | [GblId, Caf=NoCafRefs, Str=m4, Unf=OtherCon []] = |

1447 | CCS_DONT_CARE GHC.Types.KindRepFun! [$krep15_r4AP $krep12_r4AM]; |

1448 | |

1449 | $krep17_r4AR :: GHC.Types.KindRep |

1450 | [GblId, Caf=NoCafRefs, Str=m4, Unf=OtherCon []] = |

1451 | CCS_DONT_CARE GHC.Types.KindRepFun! [$krep6_r4AG $krep16_r4AQ]; |

1452 | |

1453 | Unboxed.$tc'Deep1 [InlPrag=NOUSERINLINE[~]] :: GHC.Types.KindRep |

1454 | [GblId, Caf=NoCafRefs, Str=m4, Unf=OtherCon []] = |

1455 | CCS_DONT_CARE GHC.Types.KindRepFun! [$krep2_r4AC $krep17_r4AR]; |

1456 | |

1457 | Unboxed.$tc'Deep3 :: GHC.Prim.Addr# |

1458 | [GblId, Caf=NoCafRefs, Unf=OtherCon []] = |

1459 | "'Deep"#; |

1460 | |

1461 | Unboxed.$tc'Deep2 :: GHC.Types.TrName |

1462 | [GblId, Caf=NoCafRefs, Str=m1, Unf=OtherCon []] = |

1463 | CCS_DONT_CARE GHC.Types.TrNameS! [Unboxed.$tc'Deep3]; |

1464 | |

1465 | Unboxed.$tc'Deep :: GHC.Types.TyCon |

1466 | [GblId, Caf=NoCafRefs, Str=m, Unf=OtherCon []] = |

1467 | CCS_DONT_CARE GHC.Types.TyCon! [17051504987554028038## |

1468 | 17660574047002347877## |

1469 | Unboxed.$trModule |

1470 | Unboxed.$tc'Deep2 |

1471 | 2# |

1472 | Unboxed.$tc'Deep1]; |

1473 | |

1474 | Unboxed.$tcSize2 :: GHC.Prim.Addr# |

1475 | [GblId, Caf=NoCafRefs, Unf=OtherCon []] = |

1476 | "Size"#; |

1477 | |

1478 | Unboxed.$tcSize1 :: GHC.Types.TrName |

1479 | [GblId, Caf=NoCafRefs, Str=m1, Unf=OtherCon []] = |

1480 | CCS_DONT_CARE GHC.Types.TrNameS! [Unboxed.$tcSize2]; |

1481 | |

1482 | Unboxed.$tcSize :: GHC.Types.TyCon |

1483 | [GblId, Caf=NoCafRefs, Str=m, Unf=OtherCon []] = |

1484 | CCS_DONT_CARE GHC.Types.TyCon! [1626577040394917353## |

1485 | 321012077059614582## |

1486 | Unboxed.$trModule |

1487 | Unboxed.$tcSize1 |

1488 | 0# |

1489 | GHC.Types.krep$*]; |

1490 | |

1491 | $krep18_r4AS :: GHC.Types.KindRep |

1492 | [GblId, Caf=NoCafRefs, Str=m1, Unf=OtherCon []] = |

1493 | CCS_DONT_CARE GHC.Types.KindRepTyConApp! [Unboxed.$tcSize |

1494 | GHC.Types.[]]; |

1495 | |

1496 | Unboxed.$tc'Size1 [InlPrag=NOUSERINLINE[~]] :: GHC.Types.KindRep |

1497 | [GblId, Caf=NoCafRefs, Str=m4, Unf=OtherCon []] = |

1498 | CCS_DONT_CARE GHC.Types.KindRepFun! [$krep_r4AA $krep18_r4AS]; |

1499 | |

1500 | Unboxed.$tc'Size3 :: GHC.Prim.Addr# |

1501 | [GblId, Caf=NoCafRefs, Unf=OtherCon []] = |

1502 | "'Size"#; |

1503 | |

1504 | Unboxed.$tc'Size2 :: GHC.Types.TrName |

1505 | [GblId, Caf=NoCafRefs, Str=m1, Unf=OtherCon []] = |

1506 | CCS_DONT_CARE GHC.Types.TrNameS! [Unboxed.$tc'Size3]; |

1507 | |

1508 | Unboxed.$tc'Size :: GHC.Types.TyCon |

1509 | [GblId, Caf=NoCafRefs, Str=m, Unf=OtherCon []] = |

1510 | CCS_DONT_CARE GHC.Types.TyCon! [17310009312016945755## |

1511 | 9442420112108172298## |

1512 | Unboxed.$trModule |

1513 | Unboxed.$tc'Size2 |

1514 | 0# |

1515 | Unboxed.$tc'Size1]; |

1516 | |

1517 | Unboxed.Empty :: forall v a. Unboxed.FingerTree v a |

1518 | [GblId[DataCon], Caf=NoCafRefs, Unf=OtherCon []] = |

1519 | CCS_DONT_CARE Unboxed.Empty! []; |

1520 | |

1521 | Unboxed.Single :: forall v a. a -> Unboxed.FingerTree v a |

1522 | [GblId[DataCon], |

1523 | Arity=1, |

1524 | Caf=NoCafRefs, |

1525 | Str=<L,U>m2, |

1526 | Unf=OtherCon []] = |

1527 | [] \r [eta_B1] Unboxed.Single [eta_B1]; |

1528 | |

1529 | Unboxed.Deep |

1530 | :: forall v a. |

1531 | v |

1532 | -> Unboxed.Digit a |

1533 | -> Unboxed.FingerTree v (Unboxed.Node v a) |

1534 | -> Unboxed.Digit a |

1535 | -> Unboxed.FingerTree v a |

1536 | [GblId[DataCon], |

1537 | Arity=4, |

1538 | Caf=NoCafRefs, |

1539 | Str=<L,U><L,U><L,U><L,U>m3, |

1540 | Unf=OtherCon []] = |

1541 | [] \r [eta_B4 eta_B3 eta_B2 eta_B1] |

1542 | Unboxed.Deep [eta_B4 eta_B3 eta_B2 eta_B1]; |

1543 | |

1544 | Unboxed.Node2 :: forall v a. v -> a -> a -> Unboxed.Node v a |

1545 | [GblId[DataCon], |

1546 | Arity=3, |

1547 | Caf=NoCafRefs, |

1548 | Str=<L,U><L,U><L,U>m1, |

1549 | Unf=OtherCon []] = |

1550 | [] \r [eta_B3 eta_B2 eta_B1] Unboxed.Node2 [eta_B3 eta_B2 eta_B1]; |

1551 | |

1552 | Unboxed.Node3 :: forall v a. v -> a -> a -> a -> Unboxed.Node v a |

1553 | [GblId[DataCon], |

1554 | Arity=4, |

1555 | Caf=NoCafRefs, |

1556 | Str=<L,U><L,U><L,U><L,U>m2, |

1557 | Unf=OtherCon []] = |

1558 | [] \r [eta_B4 eta_B3 eta_B2 eta_B1] |

1559 | Unboxed.Node3 [eta_B4 eta_B3 eta_B2 eta_B1]; |

1560 | |

1561 | Unboxed.One :: forall a. a -> Unboxed.Digit a |

1562 | [GblId[DataCon], |

1563 | Arity=1, |

1564 | Caf=NoCafRefs, |

1565 | Str=<L,U>m1, |

1566 | Unf=OtherCon []] = |

1567 | [] \r [eta_B1] Unboxed.One [eta_B1]; |

1568 | |

1569 | Unboxed.Two :: forall a. a -> a -> Unboxed.Digit a |

1570 | [GblId[DataCon], |

1571 | Arity=2, |

1572 | Caf=NoCafRefs, |

1573 | Str=<L,U><L,U>m2, |

1574 | Unf=OtherCon []] = |

1575 | [] \r [eta_B2 eta_B1] Unboxed.Two [eta_B2 eta_B1]; |

1576 | |

1577 | Unboxed.Three :: forall a. a -> a -> a -> Unboxed.Digit a |

1578 | [GblId[DataCon], |

1579 | Arity=3, |

1580 | Caf=NoCafRefs, |

1581 | Str=<L,U><L,U><L,U>m3, |

1582 | Unf=OtherCon []] = |

1583 | [] \r [eta_B3 eta_B2 eta_B1] Unboxed.Three [eta_B3 eta_B2 eta_B1]; |

1584 | |

1585 | Unboxed.Four :: forall a. a -> a -> a -> a -> Unboxed.Digit a |

1586 | [GblId[DataCon], |

1587 | Arity=4, |

1588 | Caf=NoCafRefs, |

1589 | Str=<L,U><L,U><L,U><L,U>m4, |

1590 | Unf=OtherCon []] = |

1591 | [] \r [eta_B4 eta_B3 eta_B2 eta_B1] |

1592 | Unboxed.Four [eta_B4 eta_B3 eta_B2 eta_B1]; |

1593 | |

1594 | |

1595 | ==================== STG syntax: ==================== |

1596 | 2018-02-15 07:12:52.753906014 UTC |

1597 | |

1598 | Unboxed.$WDeep [InlPrag=INLINE[2]] |

1599 | :: forall v a. |

1600 | v |

1601 | -> Unboxed.Digit a |

1602 | -> Unboxed.FingerTree v (Unboxed.Node v a) |

1603 | -> Unboxed.Digit a |

1604 | -> Unboxed.FingerTree v a |

1605 | [GblId[DataConWrapper], |

1606 | Arity=4, |

1607 | Caf=NoCafRefs, |

1608 | Str=<S,U><S,U><L,U><S,U>m3, |

1609 | Unf=OtherCon []] = |

1610 | [] \r [dt_s4AU dt_s4AV dt_s4AW dt_s4AX] |

1611 | case dt_s4AU of dt_s4AY { |

1612 | __DEFAULT -> |

1613 | case dt_s4AV of dt_s4AZ { |

1614 | __DEFAULT -> |

1615 | case dt_s4AX of dt_s4B0 { |

1616 | __DEFAULT -> Unboxed.Deep [dt_s4AY dt_s4AZ dt_s4AW dt_s4B0]; |

1617 | }; |

1618 | }; |

1619 | }; |

1620 | |

1621 | Unboxed.$WNode2 [InlPrag=INLINE[2]] |

1622 | :: forall v a. v -> a -> a -> Unboxed.Node v a |

1623 | [GblId[DataConWrapper], |

1624 | Arity=3, |

1625 | Caf=NoCafRefs, |

1626 | Str=<S,U><L,U><L,U>m1, |

1627 | Unf=OtherCon []] = |

1628 | [] \r [dt_s4B1 dt_s4B2 dt_s4B3] |

1629 | case dt_s4B1 of dt_s4B4 { |

1630 | __DEFAULT -> Unboxed.Node2 [dt_s4B4 dt_s4B2 dt_s4B3]; |

1631 | }; |

1632 | |

1633 | Unboxed.$WNode3 [InlPrag=INLINE[2]] |

1634 | :: forall v a. v -> a -> a -> a -> Unboxed.Node v a |

1635 | [GblId[DataConWrapper], |

1636 | Arity=4, |

1637 | Caf=NoCafRefs, |

1638 | Str=<S,U><L,U><L,U><L,U>m2, |

1639 | Unf=OtherCon []] = |

1640 | [] \r [dt_s4B5 dt_s4B6 dt_s4B7 dt_s4B8] |

1641 | case dt_s4B5 of dt_s4B9 { |

1642 | __DEFAULT -> Unboxed.Node3 [dt_s4B9 dt_s4B6 dt_s4B7 dt_s4B8]; |

1643 | }; |

1644 | |

1645 | Unboxed.$fMonoidSize_$c<> [InlPrag=INLINE (sat-args=2)] |

1646 | :: Unboxed.Size -> Unboxed.Size -> Unboxed.Size |

1647 | [GblId, |

1648 | Arity=2, |

1649 | Caf=NoCafRefs, |

1650 | Str=<S(S),1*U(U)><S(S),1*U(U)>m, |

1651 | Unf=OtherCon []] = |

1652 | [] \r [eta_B2 eta_B1] GHC.Num.$fNumInt_$c+ eta_B2 eta_B1; |

1653 | |

1654 | Unboxed.$wgo1 [InlPrag=NOUSERINLINE[0], Occ=LoopBreaker] |

1655 | :: GHC.Prim.Int# -> [Unboxed.Size] -> GHC.Prim.Int# |

1656 | [GblId, |

1657 | Arity=2, |

1658 | Caf=NoCafRefs, |

1659 | Str=<S,U><S,1*U>, |

1660 | Unf=OtherCon []] = |

1661 | [] \r [ww_s4Ba w_s4Bb] |

1662 | case w_s4Bb of { |

1663 | [] -> ww_s4Ba; |

1664 | : c_s4Bd [Occ=Once] cs_s4Be [Occ=Once] -> |

1665 | case c_s4Bd of { |

1666 | GHC.Types.I# ww2_s4Bg [Occ=Once] -> |

1667 | case Unboxed.$wgo1 ww2_s4Bg cs_s4Be of ww3_s4Bh { |

1668 | __DEFAULT -> +# [ww_s4Ba ww3_s4Bh]; |

1669 | }; |

1670 | }; |

1671 | }; |

1672 | |

1673 | Unboxed.$fSemigroupSize_go [InlPrag=NOUSERINLINE[0]] |

1674 | :: Unboxed.Size -> [Unboxed.Size] -> Unboxed.Size |

1675 | [GblId, |

1676 | Arity=2, |

1677 | Caf=NoCafRefs, |

1678 | Str=<S(S),1*U(U)><S,1*U>m, |

1679 | Unf=OtherCon []] = |

1680 | [] \r [w_s4Bi w1_s4Bj] |

1681 | case w_s4Bi of { |

1682 | GHC.Types.I# ww1_s4Bl [Occ=Once] -> |

1683 | case Unboxed.$wgo1 ww1_s4Bl w1_s4Bj of ww2_s4Bm { |

1684 | __DEFAULT -> GHC.Types.I# [ww2_s4Bm]; |

1685 | }; |

1686 | }; |

1687 | |

1688 | Unboxed.$fSemigroupSize_$csconcat |

1689 | :: GHC.Base.NonEmpty Unboxed.Size -> Unboxed.Size |

1690 | [GblId, |

1691 | Arity=1, |

1692 | Caf=NoCafRefs, |

1693 | Str=<S(S(S)S),1*U(1*U(U),1*U)>m, |

1694 | Unf=OtherCon []] = |

1695 | [] \r [ds_s4Bn] |

1696 | case ds_s4Bn of { |

1697 | GHC.Base.:| a1_s4Bp [Occ=Once] as_s4Bq [Occ=Once] -> |

1698 | Unboxed.$fSemigroupSize_go a1_s4Bp as_s4Bq; |

1699 | }; |

1700 | |

1701 | Unboxed.$fSemigroupSize [InlPrag=NOUSERINLINE CONLIKE] |

1702 | :: GHC.Base.Semigroup Unboxed.Size |

1703 | [GblId[DFunId], Str=m] = |

1704 | CCS_DONT_CARE GHC.Base.C:Semigroup! [Unboxed.$fMonoidSize_$c<> |

1705 | Unboxed.$fSemigroupSize_$csconcat |

1706 | Unboxed.$fSemigroupSize_$cstimes]; |

1707 | Unboxed.$fSemigroupSize_$cstimes [Occ=LoopBreaker] |

1708 | :: forall b. |

1709 | GHC.Real.Integral b => |

1710 | b -> Unboxed.Size -> Unboxed.Size |

1711 | [GblId, Arity=1, Str=<L,U>, Unf=OtherCon []] = |

1712 | [] \r [$dIntegral_s4Br] |

1713 | Data.Semigroup.Internal.stimesDefault |

1714 | $dIntegral_s4Br Unboxed.$fSemigroupSize; |

1715 | |

1716 | $cmempty_r3mS :: GHC.Types.Int |

1717 | [GblId, Caf=NoCafRefs, Str=m, Unf=OtherCon []] = |

1718 | CCS_DONT_CARE GHC.Types.I#! [0#]; |

1719 | |

1720 | Unboxed.$fMonoidSize_$cmempty [InlPrag=INLINE (sat-args=0)] |

1721 | :: Unboxed.Size |

1722 | [GblId, Str=m, Unf=OtherCon []] = |

1723 | [] \u [] $cmempty_r3mS; |

1724 | |

1725 | Unboxed.$wgo [InlPrag=NOUSERINLINE[0], Occ=LoopBreaker] |

1726 | :: [Unboxed.Size] -> GHC.Prim.Int# |

1727 | [GblId, Arity=1, Caf=NoCafRefs, Str=<S,1*U>, Unf=OtherCon []] = |

1728 | [] \r [w_s4Bs] |

1729 | case w_s4Bs of { |

1730 | [] -> 0#; |

1731 | : y_s4Bu [Occ=Once] ys_s4Bv [Occ=Once] -> |

1732 | case y_s4Bu of { |

1733 | GHC.Types.I# x_s4Bx [Occ=Once] -> |

1734 | case Unboxed.$wgo ys_s4Bv of ww_s4By { |

1735 | __DEFAULT -> +# [x_s4Bx ww_s4By]; |

1736 | }; |

1737 | }; |

1738 | }; |

1739 | |

1740 | Unboxed.$fMonoidSize_go [InlPrag=NOUSERINLINE[0]] |

1741 | :: [Unboxed.Size] -> Unboxed.Size |

1742 | [GblId, Arity=1, Caf=NoCafRefs, Str=<S,1*U>m, Unf=OtherCon []] = |

1743 | [] \r [w_s4Bz] |

1744 | case Unboxed.$wgo w_s4Bz of ww_s4BA { |

1745 | __DEFAULT -> GHC.Types.I# [ww_s4BA]; |

1746 | }; |

1747 | |

1748 | Unboxed.$fMonoidSize [InlPrag=NOUSERINLINE CONLIKE] |

1749 | :: GHC.Base.Monoid Unboxed.Size |

1750 | [GblId[DFunId], Str=m] = |

1751 | CCS_DONT_CARE GHC.Base.C:Monoid! [Unboxed.$fSemigroupSize |

1752 | Unboxed.$fMonoidSize_$cmempty |

1753 | Unboxed.$fMonoidSize_$c<> |

1754 | Unboxed.$fMonoidSize_go]; |

1755 | |

1756 | $dIP_r4A5 :: GHC.Prim.Addr# |

1757 | [GblId, Caf=NoCafRefs, Unf=OtherCon []] = |

1758 | "error"#; |

1759 | |

1760 | $dIP1_r4A6 :: [GHC.Types.Char] |

1761 | [GblId] = |

1762 | [] \u [] GHC.CString.unpackCString# $dIP_r4A5; |

1763 | |

1764 | loc_r4A7 :: GHC.Types.Int |

1765 | [GblId, Caf=NoCafRefs, Str=m, Unf=OtherCon []] = |

1766 | CCS_DONT_CARE GHC.Types.I#! [47#]; |

1767 | |

1768 | loc1_r4A8 :: GHC.Types.Int |

1769 | [GblId, Caf=NoCafRefs, Str=m, Unf=OtherCon []] = |

1770 | CCS_DONT_CARE GHC.Types.I#! [34#]; |

1771 | |

1772 | loc2_r4A9 :: GHC.Types.Int |

1773 | [GblId, Caf=NoCafRefs, Str=m, Unf=OtherCon []] = |

1774 | CCS_DONT_CARE GHC.Types.I#! [16#]; |

1775 | |

1776 | loc3_r4Aa :: GHC.Prim.Addr# |

1777 | [GblId, Caf=NoCafRefs, Unf=OtherCon []] = |

1778 | "Unboxed.hs"#; |

1779 | |

1780 | loc4_r4Ab :: [GHC.Types.Char] |

1781 | [GblId] = |

1782 | [] \u [] GHC.CString.unpackCString# loc3_r4Aa; |

1783 | |

1784 | Unboxed.$trModule2 :: GHC.Prim.Addr# |

1785 | [GblId, Caf=NoCafRefs, Unf=OtherCon []] = |

1786 | "Unboxed"#; |

1787 | |

1788 | loc5_r4Ac :: [GHC.Types.Char] |

1789 | [GblId] = |

1790 | [] \u [] GHC.CString.unpackCString# Unboxed.$trModule2; |

1791 | |

1792 | Unboxed.$trModule4 :: GHC.Prim.Addr# |

1793 | [GblId, Caf=NoCafRefs, Unf=OtherCon []] = |

1794 | "main"#; |

1795 | |

1796 | loc6_r4Ad :: [GHC.Types.Char] |

1797 | [GblId] = |

1798 | [] \u [] GHC.CString.unpackCString# Unboxed.$trModule4; |

1799 | |

1800 | $dIP2_r4Ae :: GHC.Stack.Types.SrcLoc |

1801 | [GblId, Str=m, Unf=OtherCon []] = |

1802 | CCS_DONT_CARE GHC.Stack.Types.SrcLoc! [loc6_r4Ad |

1803 | loc5_r4Ac |

1804 | loc4_r4Ab |

1805 | loc1_r4A8 |

1806 | loc2_r4A9 |

1807 | loc1_r4A8 |

1808 | loc_r4A7]; |

1809 | |

1810 | $dIP3_r4Af :: GHC.Stack.Types.CallStack |

1811 | [GblId, Str=m2, Unf=OtherCon []] = |

1812 | CCS_DONT_CARE GHC.Stack.Types.PushCallStack! [$dIP1_r4A6 |

1813 | $dIP2_r4Ae |

1814 | GHC.Stack.Types.EmptyCallStack]; |

1815 | |

1816 | lvl_r4Ag :: GHC.Prim.Addr# |

1817 | [GblId, Caf=NoCafRefs, Unf=OtherCon []] = |

1818 | "splitTree of Empty tree"#; |

1819 | |

1820 | lvl1_r4Ah :: [GHC.Types.Char] |

1821 | [GblId] = |

1822 | [] \u [] GHC.CString.unpackCString# lvl_r4Ag; |

1823 | |

1824 | lvl2_r4Ai :: GHC.Prim.Addr# |

1825 | [GblId, Caf=NoCafRefs, Unf=OtherCon []] = |

1826 | "undefined"#; |

1827 | |

1828 | lvl3_r4Aj :: [GHC.Types.Char] |

1829 | [GblId] = |

1830 | [] \u [] GHC.CString.unpackCString# lvl2_r4Ai; |

1831 | |

1832 | lvl4_r4Ak :: GHC.Types.Int |

1833 | [GblId, Caf=NoCafRefs, Str=m, Unf=OtherCon []] = |

1834 | CCS_DONT_CARE GHC.Types.I#! [44#]; |

1835 | |

1836 | lvl5_r4Al :: GHC.Types.Int |

1837 | [GblId, Caf=NoCafRefs, Str=m, Unf=OtherCon []] = |

1838 | CCS_DONT_CARE GHC.Types.I#! [56#]; |

1839 | |

1840 | lvl6_r4Am :: GHC.Stack.Types.SrcLoc |

1841 | [GblId, Str=m, Unf=OtherCon []] = |

1842 | CCS_DONT_CARE GHC.Stack.Types.SrcLoc! [loc6_r4Ad |

1843 | loc5_r4Ac |

1844 | loc4_r4Ab |

1845 | lvl4_r4Ak |

1846 | loc_r4A7 |

1847 | lvl4_r4Ak |

1848 | lvl5_r4Al]; |

1849 | |

1850 | lvl7_r4An :: GHC.Stack.Types.CallStack |

1851 | [GblId, Str=m2, Unf=OtherCon []] = |

1852 | CCS_DONT_CARE GHC.Stack.Types.PushCallStack! [lvl3_r4Aj |

1853 | lvl6_r4Am |

1854 | GHC.Stack.Types.EmptyCallStack]; |

1855 | |

1856 | lvl8_r4Ao |

1857 | :: forall b. |

1858 | Unboxed.FingerTree Unboxed.Size (Unboxed.Node Unboxed.Size b) |

1859 | [GblId, Str=x] = |

1860 | [] \u [] GHC.Err.undefined lvl7_r4An; |

1861 | |

1862 | lvl9_r4Ap :: GHC.Types.Int |

1863 | [GblId, Caf=NoCafRefs, Str=m, Unf=OtherCon []] = |

1864 | CCS_DONT_CARE GHC.Types.I#! [38#]; |

1865 | |

1866 | lvl10_r4Aq :: GHC.Types.Int |

1867 | [GblId, Caf=NoCafRefs, Str=m, Unf=OtherCon []] = |

1868 | CCS_DONT_CARE GHC.Types.I#! [65#]; |

1869 | |

1870 | lvl11_r4Ar :: GHC.Stack.Types.SrcLoc |

1871 | [GblId, Str=m, Unf=OtherCon []] = |

1872 | CCS_DONT_CARE GHC.Stack.Types.SrcLoc! [loc6_r4Ad |

1873 | loc5_r4Ac |

1874 | loc4_r4Ab |

1875 | lvl9_r4Ap |

1876 | lvl5_r4Al |

1877 | lvl9_r4Ap |

1878 | lvl10_r4Aq]; |

1879 | |

1880 | lvl12_r4As :: GHC.Stack.Types.CallStack |

1881 | [GblId, Str=m2, Unf=OtherCon []] = |

1882 | CCS_DONT_CARE GHC.Stack.Types.PushCallStack! [lvl3_r4Aj |

1883 | lvl11_r4Ar |

1884 | GHC.Stack.Types.EmptyCallStack]; |

1885 | |

1886 | lvl13_r4At |

1887 | :: forall b. |

1888 | Unboxed.Digit (Unboxed.Node Unboxed.Size b) |

1889 | -> Unboxed.FingerTree Unboxed.Size (Unboxed.Node Unboxed.Size b) |

1890 | [GblId, Str=x] = |

1891 | [] \u [] GHC.Err.undefined lvl12_r4As; |

1892 | |

1893 | lvl14_r4Au :: GHC.Types.Int |

1894 | [GblId, Caf=NoCafRefs, Str=m, Unf=OtherCon []] = |

1895 | CCS_DONT_CARE GHC.Types.I#! [29#]; |

1896 | |

1897 | lvl15_r4Av :: GHC.Types.Int |

1898 | [GblId, Caf=NoCafRefs, Str=m, Unf=OtherCon []] = |

1899 | CCS_DONT_CARE GHC.Types.I#! [61#]; |

1900 | |

1901 | lvl16_r4Aw :: GHC.Types.Int |

1902 | [GblId, Caf=NoCafRefs, Str=m, Unf=OtherCon []] = |

1903 | CCS_DONT_CARE GHC.Types.I#! [70#]; |

1904 | |

1905 | lvl17_r4Ax :: GHC.Stack.Types.SrcLoc |

1906 | [GblId, Str=m, Unf=OtherCon []] = |

1907 | CCS_DONT_CARE GHC.Stack.Types.SrcLoc! [loc6_r4Ad |

1908 | loc5_r4Ac |

1909 | loc4_r4Ab |

1910 | lvl14_r4Au |

1911 | lvl15_r4Av |

1912 | lvl14_r4Au |

1913 | lvl16_r4Aw]; |

1914 | |

1915 | lvl18_r4Ay :: GHC.Stack.Types.CallStack |

1916 | [GblId, Str=m2, Unf=OtherCon []] = |

1917 | CCS_DONT_CARE GHC.Stack.Types.PushCallStack! [lvl3_r4Aj |

1918 | lvl17_r4Ax |

1919 | GHC.Stack.Types.EmptyCallStack]; |

1920 | |

1921 | lvl19_r4Az |

1922 | :: forall c. |

1923 | Unboxed.FingerTree Unboxed.Size (Unboxed.Node Unboxed.Size c) |

1924 | [GblId, Str=x] = |

1925 | [] \u [] GHC.Err.undefined lvl18_r4Ay; |

1926 | |

1927 | Unboxed.$wmySplit [InlPrag=NOUSERINLINE[0]] |

1928 | :: forall c. |

1929 | GHC.Types.Int |

1930 | -> Unboxed.FingerTree Unboxed.Size (Unboxed.Node Unboxed.Size c) |

1931 | -> (# Unboxed.FingerTree |

1932 | Unboxed.Size (Unboxed.Node Unboxed.Size c), |

1933 | Unboxed.FingerTree Unboxed.Size (Unboxed.Node Unboxed.Size c) #) |

1934 | [GblId, Arity=2, Str=<L,1*U(U)><S,1*U>, Unf=OtherCon []] = |

1935 | [] \r [w_s4BB w1_s4BC] |

1936 | case w1_s4BC of { |

1937 | Unboxed.Empty -> GHC.Err.error $dIP3_r4Af lvl1_r4Ah; |

1938 | Unboxed.Single _ [Occ=Dead] -> (#,#) [Unboxed.Empty lvl19_r4Az]; |

1939 | Unboxed.Deep _ [Occ=Dead] |

1940 | pr_s4BH |

1941 | _ [Occ=Dead] |

1942 | sf_s4BJ [Occ=Once!] -> |

1943 | let-no-escape { |

1944 | $w$j_s4BK [InlPrag=NOUSERINLINE[0], |

1945 | Occ=Once*!T[1], |

1946 | Dmd=<C(S),1*C1(U(U,U))>] |

1947 | :: GHC.Prim.Int# |

1948 | -> (# Unboxed.FingerTree |

1949 | Unboxed.Size (Unboxed.Node Unboxed.Size c_s45o), |

1950 | Unboxed.FingerTree |

1951 | Unboxed.Size (Unboxed.Node Unboxed.Size c_s45o) #) |

1952 | [LclId[JoinId(1)], Arity=1, Str=<S,U>, Unf=OtherCon []] = |

1953 | sat-only [w_s4BB pr_s4BH sf_s4BJ] \r [w2_s4BL] |

1954 | case w_s4BB of { |

1955 | GHC.Types.I# y_s4BN -> |

1956 | case ># [w2_s4BL y_s4BN] of { |

1957 | __DEFAULT -> |

1958 | case sf_s4BJ of { |

1959 | Unboxed.One _ [Occ=Dead] -> (#,#) [lvl8_r4Ao lvl19_r4Az]; |

1960 | Unboxed.Two a_s4BR [Occ=Once] _ [Occ=Dead] -> |

1961 | case a_s4BR of { |

1962 | __DEFAULT -> (#,#) [lvl8_r4Ao lvl19_r4Az]; |

1963 | }; |

1964 | Unboxed.Three a_s4BU [Occ=Once!] |

1965 | b_s4BV [Occ=Once*] |

1966 | _ [Occ=Dead] -> |

1967 | case a_s4BU of { |

1968 | Unboxed.Node2 v_s4BY [Occ=Once] |

1969 | _ [Occ=Dead] |

1970 | _ [Occ=Dead] -> |

1971 | case v_s4BY of { |

1972 | GHC.Types.I# y1_s4C2 [Occ=Once] -> |

1973 | case +# [w2_s4BL y1_s4C2] of sat_s4C3 { |

1974 | __DEFAULT -> |

1975 | case ># [sat_s4C3 y_s4BN] of { |

1976 | __DEFAULT -> |

1977 | case b_s4BV of { |

1978 | __DEFAULT -> |

1979 | (#,#) [lvl8_r4Ao |

1980 | lvl19_r4Az]; |

1981 | }; |

1982 | 1# -> (#,#) [lvl8_r4Ao lvl19_r4Az]; |

1983 | }; |

1984 | }; |

1985 | }; |

1986 | Unboxed.Node3 v_s4C6 [Occ=Once] |

1987 | _ [Occ=Dead] |

1988 | _ [Occ=Dead] |

1989 | _ [Occ=Dead] -> |

1990 | case v_s4C6 of { |

1991 | GHC.Types.I# y1_s4Cb [Occ=Once] -> |

1992 | case +# [w2_s4BL y1_s4Cb] of sat_s4Cc { |

1993 | __DEFAULT -> |

1994 | case ># [sat_s4Cc y_s4BN] of { |

1995 | __DEFAULT -> |

1996 | case b_s4BV of { |

1997 | __DEFAULT -> |

1998 | (#,#) [lvl8_r4Ao |

1999 | lvl19_r4Az]; |

2000 | }; |

2001 | 1# -> (#,#) [lvl8_r4Ao lvl19_r4Az]; |

2002 | }; |

2003 | }; |

2004 | }; |

2005 | }; |

2006 | Unboxed.Four a_s4Cf [Occ=Once!] |

2007 | b_s4Cg [Occ=Once!] |

2008 | c1_s4Ch [Occ=Once*] |

2009 | _ [Occ=Dead] -> |

2010 | let-no-escape { |

2011 | $j_s4Cj [Occ=Once*!T[1], Dmd=<C(S),1*C1(U(U,U))>] |

2012 | :: GHC.Prim.Int# |

2013 | -> (# Unboxed.FingerTree |

2014 | Unboxed.Size |

2015 | (Unboxed.Node Unboxed.Size c_s45o), |

2016 | Unboxed.FingerTree |

2017 | Unboxed.Size |

2018 | (Unboxed.Node Unboxed.Size c_s45o) #) |

2019 | [LclId[JoinId(1)], |

2020 | Arity=1, |

2021 | Str=<S,U>, |

2022 | Unf=OtherCon []] = |

2023 | sat-only [y_s4BN b_s4Cg c1_s4Ch] \r [x_s4Ck] |

2024 | case ># [x_s4Ck y_s4BN] of { |

2025 | __DEFAULT -> |

2026 | case b_s4Cg of { |

2027 | Unboxed.Node2 v_s4Cn [Occ=Once] |

2028 | _ [Occ=Dead] |

2029 | _ [Occ=Dead] -> |

2030 | case v_s4Cn of { |

2031 | GHC.Types.I# y1_s4Cr [Occ=Once] -> |

2032 | case |

2033 | +# [x_s4Ck y1_s4Cr] |

2034 | of |

2035 | sat_s4Cs |

2036 | { __DEFAULT -> |

2037 | case |

2038 | ># [sat_s4Cs y_s4BN] |

2039 | of |

2040 | { __DEFAULT -> |

2041 | case c1_s4Ch of { |

2042 | __DEFAULT -> |

2043 | (#,#) [lvl8_r4Ao |

2044 | lvl19_r4Az]; |

2045 | }; |

2046 | 1# -> |

2047 | (#,#) [lvl8_r4Ao |

2048 | lvl19_r4Az]; |

2049 | }; |

2050 | }; |

2051 | }; |

2052 | Unboxed.Node3 v_s4Cv [Occ=Once] |

2053 | _ [Occ=Dead] |

2054 | _ [Occ=Dead] |

2055 | _ [Occ=Dead] -> |

2056 | case v_s4Cv of { |

2057 | GHC.Types.I# y1_s4CA [Occ=Once] -> |

2058 | case |

2059 | +# [x_s4Ck y1_s4CA] |

2060 | of |

2061 | sat_s4CB |

2062 | { __DEFAULT -> |

2063 | case |

2064 | ># [sat_s4CB y_s4BN] |

2065 | of |

2066 | { __DEFAULT -> |

2067 | case c1_s4Ch of { |

2068 | __DEFAULT -> |

2069 | (#,#) [lvl8_r4Ao |

2070 | lvl19_r4Az]; |

2071 | }; |

2072 | 1# -> |

2073 | (#,#) [lvl8_r4Ao |

2074 | lvl19_r4Az]; |

2075 | }; |

2076 | }; |

2077 | }; |

2078 | }; |

2079 | 1# -> (#,#) [lvl8_r4Ao lvl19_r4Az]; |

2080 | }; |

2081 | } in |

2082 | case a_s4Cf of { |

2083 | Unboxed.Node2 v_s4CF [Occ=Once] |

2084 | _ [Occ=Dead] |

2085 | _ [Occ=Dead] -> |

2086 | case v_s4CF of { |

2087 | GHC.Types.I# y1_s4CJ [Occ=Once] -> |

2088 | case +# [w2_s4BL y1_s4CJ] of sat_s4CK { |

2089 | __DEFAULT -> $j_s4Cj sat_s4CK; |

2090 | }; |

2091 | }; |

2092 | Unboxed.Node3 v_s4CL [Occ=Once] |

2093 | _ [Occ=Dead] |

2094 | _ [Occ=Dead] |

2095 | _ [Occ=Dead] -> |

2096 | case v_s4CL of { |

2097 | GHC.Types.I# y1_s4CQ [Occ=Once] -> |

2098 | case +# [w2_s4BL y1_s4CQ] of sat_s4CR { |

2099 | __DEFAULT -> $j_s4Cj sat_s4CR; |

2100 | }; |

2101 | }; |

2102 | }; |

2103 | }; |

2104 | 1# -> |

2105 | case pr_s4BH of { |

2106 | Unboxed.One _ [Occ=Dead] -> (#,#) [Unboxed.Empty lvl19_r4Az]; |

2107 | Unboxed.Two a_s4CU [Occ=Once!] _ [Occ=Dead] -> |

2108 | case a_s4CU of { |

2109 | Unboxed.Node2 v_s4CX [Occ=Once] |

2110 | _ [Occ=Dead] |

2111 | _ [Occ=Dead] -> |

2112 | case v_s4CX of { |

2113 | GHC.Types.I# y1_s4D1 [Occ=Once] -> |

2114 | case ># [y1_s4D1 y_s4BN] of { |

2115 | __DEFAULT -> (#,#) [lvl13_r4At lvl19_r4Az]; |

2116 | 1# -> (#,#) [Unboxed.Empty lvl19_r4Az]; |

2117 | }; |

2118 | }; |

2119 | Unboxed.Node3 v_s4D4 [Occ=Once] |

2120 | _ [Occ=Dead] |

2121 | _ [Occ=Dead] |

2122 | _ [Occ=Dead] -> |

2123 | case v_s4D4 of { |

2124 | GHC.Types.I# y1_s4D9 [Occ=Once] -> |

2125 | case ># [y1_s4D9 y_s4BN] of { |

2126 | __DEFAULT -> (#,#) [lvl13_r4At lvl19_r4Az]; |

2127 | 1# -> (#,#) [Unboxed.Empty lvl19_r4Az]; |

2128 | }; |

2129 | }; |

2130 | }; |

2131 | Unboxed.Three a_s4Dc [Occ=Once!] |

2132 | b_s4Dd [Occ=Once!] |

2133 | _ [Occ=Dead] -> |

2134 | let-no-escape { |

2135 | $j_s4Df [Occ=Once*!T[1], Dmd=<C(S),1*C1(U(U,U))>] |

2136 | :: GHC.Prim.Int# |

2137 | -> (# Unboxed.FingerTree |

2138 | Unboxed.Size |

2139 | (Unboxed.Node Unboxed.Size c_s45o), |

2140 | Unboxed.FingerTree |

2141 | Unboxed.Size |

2142 | (Unboxed.Node Unboxed.Size c_s45o) #) |

2143 | [LclId[JoinId(1)], |

2144 | Arity=1, |

2145 | Str=<S,U>, |

2146 | Unf=OtherCon []] = |

2147 | sat-only [y_s4BN b_s4Dd] \r [x_s4Dg] |

2148 | case ># [x_s4Dg y_s4BN] of { |

2149 | __DEFAULT -> |

2150 | case b_s4Dd of { |

2151 | Unboxed.Node2 v_s4Dj [Occ=Once] |

2152 | _ [Occ=Dead] |

2153 | _ [Occ=Dead] -> |

2154 | case v_s4Dj of { |

2155 | GHC.Types.I# y1_s4Dn [Occ=Once] -> |

2156 | case |

2157 | +# [x_s4Dg y1_s4Dn] |

2158 | of |

2159 | sat_s4Do |

2160 | { __DEFAULT -> |

2161 | case |

2162 | ># [sat_s4Do y_s4BN] |

2163 | of |

2164 | { __DEFAULT -> |

2165 | (#,#) [lvl13_r4At |

2166 | lvl19_r4Az]; |

2167 | 1# -> |

2168 | (#,#) [lvl13_r4At |

2169 | lvl19_r4Az]; |

2170 | }; |

2171 | }; |

2172 | }; |

2173 | Unboxed.Node3 v_s4Ds [Occ=Once] |

2174 | _ [Occ=Dead] |

2175 | _ [Occ=Dead] |

2176 | _ [Occ=Dead] -> |

2177 | case v_s4Ds of { |

2178 | GHC.Types.I# y1_s4Dx [Occ=Once] -> |

2179 | case |

2180 | +# [x_s4Dg y1_s4Dx] |

2181 | of |

2182 | sat_s4Dy |

2183 | { __DEFAULT -> |

2184 | case |

2185 | ># [sat_s4Dy y_s4BN] |

2186 | of |

2187 | { __DEFAULT -> |

2188 | (#,#) [lvl13_r4At |

2189 | lvl19_r4Az]; |

2190 | 1# -> |

2191 | (#,#) [lvl13_r4At |

2192 | lvl19_r4Az]; |

2193 | }; |

2194 | }; |

2195 | }; |

2196 | }; |

2197 | 1# -> (#,#) [Unboxed.Empty lvl19_r4Az]; |

2198 | }; |

2199 | } in |

2200 | case a_s4Dc of { |

2201 | Unboxed.Node2 v_s4DD [Occ=Once] |

2202 | _ [Occ=Dead] |

2203 | _ [Occ=Dead] -> |

2204 | case v_s4DD of { |

2205 | GHC.Types.I# y1_s4DH [Occ=Once] -> |

2206 | $j_s4Df y1_s4DH; |

2207 | }; |

2208 | Unboxed.Node3 v_s4DI [Occ=Once] |

2209 | _ [Occ=Dead] |

2210 | _ [Occ=Dead] |

2211 | _ [Occ=Dead] -> |

2212 | case v_s4DI of { |

2213 | GHC.Types.I# y1_s4DN [Occ=Once] -> |

2214 | $j_s4Df y1_s4DN; |

2215 | }; |

2216 | }; |

2217 | Unboxed.Four a_s4DO [Occ=Once!] |

2218 | b_s4DP [Occ=Once!] |

2219 | c1_s4DQ [Occ=Once!] |

2220 | _ [Occ=Dead] -> |

2221 | let-no-escape { |

2222 | $j_s4DS [Occ=Once*!T[1], Dmd=<C(S),1*C1(U(U,U))>] |

2223 | :: GHC.Prim.Int# |

2224 | -> (# Unboxed.FingerTree |

2225 | Unboxed.Size |

2226 | (Unboxed.Node Unboxed.Size c_s45o), |

2227 | Unboxed.FingerTree |

2228 | Unboxed.Size |

2229 | (Unboxed.Node Unboxed.Size c_s45o) #) |

2230 | [LclId[JoinId(1)], |

2231 | Arity=1, |

2232 | Str=<S,U>, |

2233 | Unf=OtherCon []] = |

2234 | sat-only [y_s4BN b_s4DP c1_s4DQ] \r [x_s4DT] |

2235 | case ># [x_s4DT y_s4BN] of { |

2236 | __DEFAULT -> |

2237 | let-no-escape { |

2238 | $j1_s4DV [Occ=Once*!T[1], |

2239 | Dmd=<C(S),1*C1(U(U,U))>] |

2240 | :: GHC.Prim.Int# |

2241 | -> (# Unboxed.FingerTree |

2242 | Unboxed.Size |

2243 | (Unboxed.Node |

2244 | Unboxed.Size c_s45o), |

2245 | Unboxed.FingerTree |

2246 | Unboxed.Size |

2247 | (Unboxed.Node |

2248 | Unboxed.Size c_s45o) #) |

2249 | [LclId[JoinId(1)], |

2250 | Arity=1, |

2251 | Str=<S,U>, |

2252 | Unf=OtherCon []] = |

2253 | sat-only [y_s4BN |

2254 | c1_s4DQ] \r [x1_s4DW] |

2255 | case ># [x1_s4DW y_s4BN] of { |

2256 | __DEFAULT -> |

2257 | case c1_s4DQ of { |

2258 | Unboxed.Node2 v_s4DZ [Occ=Once] |

2259 | _ [Occ=Dead] |

2260 | _ [Occ=Dead] -> |

2261 | case v_s4DZ of { |

2262 | GHC.Types.I# y1_s4E3 [Occ=Once] -> |

2263 | case |

2264 | +# [x1_s4DW |

2265 | y1_s4E3] |

2266 | of |

2267 | sat_s4E4 |

2268 | { __DEFAULT -> |

2269 | case |

2270 | ># [sat_s4E4 |

2271 | y_s4BN] |

2272 | of |

2273 | { __DEFAULT -> |

2274 | (#,#) [lvl13_r4At |

2275 | lvl19_r4Az]; |

2276 | 1# -> |

2277 | (#,#) [lvl13_r4At |

2278 | lvl19_r4Az]; |

2279 | }; |

2280 | }; |

2281 | }; |

2282 | Unboxed.Node3 v_s4E8 [Occ=Once] |

2283 | _ [Occ=Dead] |

2284 | _ [Occ=Dead] |

2285 | _ [Occ=Dead] -> |

2286 | case v_s4E8 of { |

2287 | GHC.Types.I# y1_s4Ed [Occ=Once] -> |

2288 | case |

2289 | +# [x1_s4DW |

2290 | y1_s4Ed] |

2291 | of |

2292 | sat_s4Ee |

2293 | { __DEFAULT -> |

2294 | case |

2295 | ># [sat_s4Ee |

2296 | y_s4BN] |

2297 | of |

2298 | { __DEFAULT -> |

2299 | (#,#) [lvl13_r4At |

2300 | lvl19_r4Az]; |

2301 | 1# -> |

2302 | (#,#) [lvl13_r4At |

2303 | lvl19_r4Az]; |

2304 | }; |

2305 | }; |

2306 | }; |

2307 | }; |

2308 | 1# -> |

2309 | (#,#) [lvl13_r4At |

2310 | lvl19_r4Az]; |

2311 | }; |

2312 | } in |

2313 | case b_s4DP of { |

2314 | Unboxed.Node2 v_s4Ek [Occ=Once] |

2315 | _ [Occ=Dead] |

2316 | _ [Occ=Dead] -> |

2317 | case v_s4Ek of { |

2318 | GHC.Types.I# y1_s4Eo [Occ=Once] -> |

2319 | case |

2320 | +# [x_s4DT y1_s4Eo] |

2321 | of |

2322 | sat_s4Ep |

2323 | { __DEFAULT -> |

2324 | $j1_s4DV sat_s4Ep; |

2325 | }; |

2326 | }; |

2327 | Unboxed.Node3 v_s4Eq [Occ=Once] |

2328 | _ [Occ=Dead] |

2329 | _ [Occ=Dead] |

2330 | _ [Occ=Dead] -> |

2331 | case v_s4Eq of { |

2332 | GHC.Types.I# y1_s4Ev [Occ=Once] -> |

2333 | case |

2334 | +# [x_s4DT y1_s4Ev] |

2335 | of |

2336 | sat_s4Ew |

2337 | { __DEFAULT -> |

2338 | $j1_s4DV sat_s4Ew; |

2339 | }; |

2340 | }; |

2341 | }; |

2342 | 1# -> (#,#) [Unboxed.Empty lvl19_r4Az]; |

2343 | }; |

2344 | } in |

2345 | case a_s4DO of { |

2346 | Unboxed.Node2 v_s4Ey [Occ=Once] |

2347 | _ [Occ=Dead] |

2348 | _ [Occ=Dead] -> |

2349 | case v_s4Ey of { |

2350 | GHC.Types.I# y1_s4EC [Occ=Once] -> |

2351 | $j_s4DS y1_s4EC; |

2352 | }; |

2353 | Unboxed.Node3 v_s4ED [Occ=Once] |

2354 | _ [Occ=Dead] |

2355 | _ [Occ=Dead] |

2356 | _ [Occ=Dead] -> |

2357 | case v_s4ED of { |

2358 | GHC.Types.I# y1_s4EI [Occ=Once] -> |

2359 | $j_s4DS y1_s4EI; |

2360 | }; |

2361 | }; |

2362 | }; |

2363 | }; |

2364 | }; |

2365 | } in |

2366 | case pr_s4BH of { |

2367 | Unboxed.One a_s4EK [Occ=Once!] -> |

2368 | case a_s4EK of { |

2369 | Unboxed.Node2 v_s4EM [Occ=Once] _ [Occ=Dead] _ [Occ=Dead] -> |

2370 | case v_s4EM of { |

2371 | GHC.Types.I# y_s4EQ [Occ=Once] -> $w$j_s4BK y_s4EQ; |

2372 | }; |

2373 | Unboxed.Node3 v_s4ER [Occ=Once] |

2374 | _ [Occ=Dead] |

2375 | _ [Occ=Dead] |

2376 | _ [Occ=Dead] -> |

2377 | case v_s4ER of { |

2378 | GHC.Types.I# y_s4EW [Occ=Once] -> $w$j_s4BK y_s4EW; |

2379 | }; |

2380 | }; |

2381 | Unboxed.Two a_s4EX [Occ=Once!] b_s4EY [Occ=Once*!] -> |

2382 | case a_s4EX of { |

2383 | Unboxed.Node2 v_s4F0 [Occ=Once] _ [Occ=Dead] _ [Occ=Dead] -> |

2384 | case v_s4F0 of { |

2385 | GHC.Types.I# x_s4F4 [Occ=Once*] -> |

2386 | case b_s4EY of { |

2387 | Unboxed.Node2 v1_s4F6 [Occ=Once] _ [Occ=Dead] _ [Occ=Dead] -> |

2388 | case v1_s4F6 of { |

2389 | GHC.Types.I# y_s4Fa [Occ=Once] -> |

2390 | case +# [x_s4F4 y_s4Fa] of sat_s4Fb { |

2391 | __DEFAULT -> $w$j_s4BK sat_s4Fb; |

2392 | }; |

2393 | }; |

2394 | Unboxed.Node3 v1_s4Fc [Occ=Once] |

2395 | _ [Occ=Dead] |

2396 | _ [Occ=Dead] |

2397 | _ [Occ=Dead] -> |

2398 | case v1_s4Fc of { |

2399 | GHC.Types.I# y_s4Fh [Occ=Once] -> |

2400 | case +# [x_s4F4 y_s4Fh] of sat_s4Fi { |

2401 | __DEFAULT -> $w$j_s4BK sat_s4Fi; |

2402 | }; |

2403 | }; |

2404 | }; |

2405 | }; |

2406 | Unboxed.Node3 v_s4Fj [Occ=Once] |

2407 | _ [Occ=Dead] |

2408 | _ [Occ=Dead] |

2409 | _ [Occ=Dead] -> |

2410 | case v_s4Fj of { |

2411 | GHC.Types.I# x_s4Fo [Occ=Once*] -> |

2412 | case b_s4EY of { |

2413 | Unboxed.Node2 v1_s4Fq [Occ=Once] _ [Occ=Dead] _ [Occ=Dead] -> |

2414 | case v1_s4Fq of { |

2415 | GHC.Types.I# y_s4Fu [Occ=Once] -> |

2416 | case +# [x_s4Fo y_s4Fu] of sat_s4Fv { |

2417 | __DEFAULT -> $w$j_s4BK sat_s4Fv; |

2418 | }; |

2419 | }; |

2420 | Unboxed.Node3 v1_s4Fw [Occ=Once] |

2421 | _ [Occ=Dead] |

2422 | _ [Occ=Dead] |

2423 | _ [Occ=Dead] -> |

2424 | case v1_s4Fw of { |

2425 | GHC.Types.I# y_s4FB [Occ=Once] -> |

2426 | case +# [x_s4Fo y_s4FB] of sat_s4FC { |

2427 | __DEFAULT -> $w$j_s4BK sat_s4FC; |

2428 | }; |

2429 | }; |

2430 | }; |

2431 | }; |

2432 | }; |

2433 | Unboxed.Three a_s4FD [Occ=Once!] |

2434 | b_s4FE [Occ=Once!] |

2435 | c1_s4FF [Occ=Once*!] -> |

2436 | let-no-escape { |

2437 | $j_s4FG [Occ=Once*!T[1], Dmd=<C(S),1*C1(U(U,U))>] |

2438 | :: GHC.Prim.Int# |

2439 | -> (# Unboxed.FingerTree |

2440 | Unboxed.Size (Unboxed.Node Unboxed.Size c_s45o), |

2441 | Unboxed.FingerTree |

2442 | Unboxed.Size (Unboxed.Node Unboxed.Size c_s45o) #) |

2443 | [LclId[JoinId(1)], Arity=1, Str=<S,U>, Unf=OtherCon []] = |

2444 | sat-only [$w$j_s4BK b_s4FE c1_s4FF] \r [x_s4FH] |

2445 | case b_s4FE of { |

2446 | Unboxed.Node2 v_s4FJ [Occ=Once] _ [Occ=Dead] _ [Occ=Dead] -> |

2447 | case v_s4FJ of { |

2448 | GHC.Types.I# y_s4FN [Occ=Once*] -> |

2449 | case c1_s4FF of { |

2450 | Unboxed.Node2 v1_s4FP [Occ=Once] |

2451 | _ [Occ=Dead] |

2452 | _ [Occ=Dead] -> |

2453 | case v1_s4FP of { |

2454 | GHC.Types.I# y1_s4FT [Occ=Once] -> |

2455 | case +# [x_s4FH y_s4FN] of sat_s4FU { |

2456 | __DEFAULT -> |

2457 | case |

2458 | +# [sat_s4FU y1_s4FT] |

2459 | of |

2460 | sat_s4FV |

2461 | { __DEFAULT -> $w$j_s4BK sat_s4FV; |

2462 | }; |

2463 | }; |

2464 | }; |

2465 | Unboxed.Node3 v1_s4FW [Occ=Once] |

2466 | _ [Occ=Dead] |

2467 | _ [Occ=Dead] |

2468 | _ [Occ=Dead] -> |

2469 | case v1_s4FW of { |

2470 | GHC.Types.I# y1_s4G1 [Occ=Once] -> |

2471 | case +# [x_s4FH y_s4FN] of sat_s4G2 { |

2472 | __DEFAULT -> |

2473 | case |

2474 | +# [sat_s4G2 y1_s4G1] |

2475 | of |

2476 | sat_s4G3 |

2477 | { __DEFAULT -> $w$j_s4BK sat_s4G3; |

2478 | }; |

2479 | }; |

2480 | }; |

2481 | }; |

2482 | }; |

2483 | Unboxed.Node3 v_s4G4 [Occ=Once] |

2484 | _ [Occ=Dead] |

2485 | _ [Occ=Dead] |

2486 | _ [Occ=Dead] -> |

2487 | case v_s4G4 of { |

2488 | GHC.Types.I# y_s4G9 [Occ=Once*] -> |

2489 | case c1_s4FF of { |

2490 | Unboxed.Node2 v1_s4Gb [Occ=Once] |

2491 | _ [Occ=Dead] |

2492 | _ [Occ=Dead] -> |

2493 | case v1_s4Gb of { |

2494 | GHC.Types.I# y1_s4Gf [Occ=Once] -> |

2495 | case +# [x_s4FH y_s4G9] of sat_s4Gg { |

2496 | __DEFAULT -> |

2497 | case |

2498 | +# [sat_s4Gg y1_s4Gf] |

2499 | of |

2500 | sat_s4Gh |

2501 | { __DEFAULT -> $w$j_s4BK sat_s4Gh; |

2502 | }; |

2503 | }; |

2504 | }; |

2505 | Unboxed.Node3 v1_s4Gi [Occ=Once] |

2506 | _ [Occ=Dead] |

2507 | _ [Occ=Dead] |

2508 | _ [Occ=Dead] -> |

2509 | case v1_s4Gi of { |

2510 | GHC.Types.I# y1_s4Gn [Occ=Once] -> |

2511 | case +# [x_s4FH y_s4G9] of sat_s4Go { |

2512 | __DEFAULT -> |

2513 | case |

2514 | +# [sat_s4Go y1_s4Gn] |

2515 | of |

2516 | sat_s4Gp |

2517 | { __DEFAULT -> $w$j_s4BK sat_s4Gp; |

2518 | }; |

2519 | }; |

2520 | }; |

2521 | }; |

2522 | }; |

2523 | }; |

2524 | } in |

2525 | case a_s4FD of { |

2526 | Unboxed.Node2 v_s4Gr [Occ=Once] _ [Occ=Dead] _ [Occ=Dead] -> |

2527 | case v_s4Gr of { |

2528 | GHC.Types.I# x_s4Gv [Occ=Once] -> $j_s4FG x_s4Gv; |

2529 | }; |

2530 | Unboxed.Node3 v_s4Gw [Occ=Once] |

2531 | _ [Occ=Dead] |

2532 | _ [Occ=Dead] |

2533 | _ [Occ=Dead] -> |

2534 | case v_s4Gw of { |

2535 | GHC.Types.I# x_s4GB [Occ=Once] -> $j_s4FG x_s4GB; |

2536 | }; |

2537 | }; |

2538 | Unboxed.Four a_s4GC [Occ=Once!] |

2539 | b_s4GD [Occ=Once!] |

2540 | c1_s4GE [Occ=Once!] |

2541 | d_s4GF [Occ=Once*!] -> |

2542 | let-no-escape { |

2543 | $j_s4GG [Occ=Once*!T[1], Dmd=<C(S),1*C1(U(U,U))>] |

2544 | :: GHC.Prim.Int# |

2545 | -> (# Unboxed.FingerTree |

2546 | Unboxed.Size (Unboxed.Node Unboxed.Size c_s45o), |

2547 | Unboxed.FingerTree |

2548 | Unboxed.Size (Unboxed.Node Unboxed.Size c_s45o) #) |

2549 | [LclId[JoinId(1)], Arity=1, Str=<S,U>, Unf=OtherCon []] = |

2550 | sat-only [$w$j_s4BK b_s4GD c1_s4GE d_s4GF] \r [x_s4GH] |

2551 | let-no-escape { |

2552 | $j1_s4GI [Occ=Once*!T[1], Dmd=<C(S),1*C1(U(U,U))>] |

2553 | :: GHC.Prim.Int# |

2554 | -> (# Unboxed.FingerTree |

2555 | Unboxed.Size (Unboxed.Node Unboxed.Size c_s45o), |

2556 | Unboxed.FingerTree |

2557 | Unboxed.Size (Unboxed.Node Unboxed.Size c_s45o) #) |

2558 | [LclId[JoinId(1)], Arity=1, Str=<S,U>, Unf=OtherCon []] = |

2559 | sat-only [$w$j_s4BK c1_s4GE d_s4GF x_s4GH] \r [y_s4GJ] |

2560 | case c1_s4GE of { |

2561 | Unboxed.Node2 v_s4GL [Occ=Once] |

2562 | _ [Occ=Dead] |

2563 | _ [Occ=Dead] -> |

2564 | case v_s4GL of { |

2565 | GHC.Types.I# y1_s4GP [Occ=Once*] -> |

2566 | case d_s4GF of { |

2567 | Unboxed.Node2 v1_s4GR [Occ=Once] |

2568 | _ [Occ=Dead] |

2569 | _ [Occ=Dead] -> |

2570 | case v1_s4GR of { |

2571 | GHC.Types.I# y2_s4GV [Occ=Once] -> |

2572 | case |

2573 | +# [x_s4GH y_s4GJ] |

2574 | of |

2575 | sat_s4GW |

2576 | { __DEFAULT -> |

2577 | case |

2578 | +# [sat_s4GW y1_s4GP] |

2579 | of |

2580 | sat_s4GX |

2581 | { __DEFAULT -> |

2582 | case |

2583 | +# [sat_s4GX |

2584 | y2_s4GV] |

2585 | of |

2586 | sat_s4GY |

2587 | { __DEFAULT -> |

2588 | $w$j_s4BK |

2589 | sat_s4GY; |

2590 | }; |

2591 | }; |

2592 | }; |

2593 | }; |

2594 | Unboxed.Node3 v1_s4GZ [Occ=Once] |

2595 | _ [Occ=Dead] |

2596 | _ [Occ=Dead] |

2597 | _ [Occ=Dead] -> |

2598 | case v1_s4GZ of { |

2599 | GHC.Types.I# y2_s4H4 [Occ=Once] -> |

2600 | case |

2601 | +# [x_s4GH y_s4GJ] |

2602 | of |

2603 | sat_s4H5 |

2604 | { __DEFAULT -> |

2605 | case |

2606 | +# [sat_s4H5 y1_s4GP] |

2607 | of |

2608 | sat_s4H6 |

2609 | { __DEFAULT -> |

2610 | case |

2611 | +# [sat_s4H6 |

2612 | y2_s4H4] |

2613 | of |

2614 | sat_s4H7 |

2615 | { __DEFAULT -> |

2616 | $w$j_s4BK |

2617 | sat_s4H7; |

2618 | }; |

2619 | }; |

2620 | }; |

2621 | }; |

2622 | }; |

2623 | }; |

2624 | Unboxed.Node3 v_s4H8 [Occ=Once] |

2625 | _ [Occ=Dead] |

2626 | _ [Occ=Dead] |

2627 | _ [Occ=Dead] -> |

2628 | case v_s4H8 of { |

2629 | GHC.Types.I# y1_s4Hd [Occ=Once*] -> |

2630 | case d_s4GF of { |

2631 | Unboxed.Node2 v1_s4Hf [Occ=Once] |

2632 | _ [Occ=Dead] |

2633 | _ [Occ=Dead] -> |

2634 | case v1_s4Hf of { |

2635 | GHC.Types.I# y2_s4Hj [Occ=Once] -> |

2636 | case |

2637 | +# [x_s4GH y_s4GJ] |

2638 | of |

2639 | sat_s4Hk |

2640 | { __DEFAULT -> |

2641 | case |

2642 | +# [sat_s4Hk y1_s4Hd] |

2643 | of |

2644 | sat_s4Hl |

2645 | { __DEFAULT -> |

2646 | case |

2647 | +# [sat_s4Hl |

2648 | y2_s4Hj] |

2649 | of |

2650 | sat_s4Hm |

2651 | { __DEFAULT -> |

2652 | $w$j_s4BK |

2653 | sat_s4Hm; |

2654 | }; |

2655 | }; |

2656 | }; |

2657 | }; |

2658 | Unboxed.Node3 v1_s4Hn [Occ=Once] |

2659 | _ [Occ=Dead] |

2660 | _ [Occ=Dead] |

2661 | _ [Occ=Dead] -> |

2662 | case v1_s4Hn of { |

2663 | GHC.Types.I# y2_s4Hs [Occ=Once] -> |

2664 | case |

2665 | +# [x_s4GH y_s4GJ] |

2666 | of |

2667 | sat_s4Ht |

2668 | { __DEFAULT -> |

2669 | case |

2670 | +# [sat_s4Ht y1_s4Hd] |

2671 | of |

2672 | sat_s4Hu |

2673 | { __DEFAULT -> |

2674 | case |

2675 | +# [sat_s4Hu |

2676 | y2_s4Hs] |

2677 | of |

2678 | sat_s4Hv |

2679 | { __DEFAULT -> |

2680 | $w$j_s4BK |

2681 | sat_s4Hv; |

2682 | }; |

2683 | }; |

2684 | }; |

2685 | }; |

2686 | }; |

2687 | }; |

2688 | }; |

2689 | } in |

2690 | case b_s4GD of { |

2691 | Unboxed.Node2 v_s4Hx [Occ=Once] _ [Occ=Dead] _ [Occ=Dead] -> |

2692 | case v_s4Hx of { |

2693 | GHC.Types.I# y_s4HB [Occ=Once] -> $j1_s4GI y_s4HB; |

2694 | }; |

2695 | Unboxed.Node3 v_s4HC [Occ=Once] |

2696 | _ [Occ=Dead] |

2697 | _ [Occ=Dead] |

2698 | _ [Occ=Dead] -> |

2699 | case v_s4HC of { |

2700 | GHC.Types.I# y_s4HH [Occ=Once] -> $j1_s4GI y_s4HH; |

2701 | }; |

2702 | }; |

2703 | } in |

2704 | case a_s4GC of { |

2705 | Unboxed.Node2 v_s4HJ [Occ=Once] _ [Occ=Dead] _ [Occ=Dead] -> |

2706 | case v_s4HJ of { |

2707 | GHC.Types.I# x_s4HN [Occ=Once] -> $j_s4GG x_s4HN; |

2708 | }; |

2709 | Unboxed.Node3 v_s4HO [Occ=Once] |

2710 | _ [Occ=Dead] |

2711 | _ [Occ=Dead] |

2712 | _ [Occ=Dead] -> |

2713 | case v_s4HO of { |

2714 | GHC.Types.I# x_s4HT [Occ=Once] -> $j_s4GG x_s4HT; |

2715 | }; |

2716 | }; |

2717 | }; |

2718 | }; |

2719 | |

2720 | Unboxed.mySplit [InlPrag=NOUSERINLINE[0]] |

2721 | :: forall c. |

2722 | GHC.Types.Int |

2723 | -> Unboxed.FingerTree Unboxed.Size (Unboxed.Node Unboxed.Size c) |

2724 | -> (Unboxed.FingerTree Unboxed.Size (Unboxed.Node Unboxed.Size c), |

2725 | Unboxed.FingerTree Unboxed.Size (Unboxed.Node Unboxed.Size c)) |

2726 | [GblId, Arity=2, Str=<L,1*U(U)><S,1*U>m, Unf=OtherCon []] = |

2727 | [] \r [w_s4HU w1_s4HV] |

2728 | case Unboxed.$wmySplit w_s4HU w1_s4HV of { |

2729 | (#,#) ww1_s4HX [Occ=Once] ww2_s4HY [Occ=Once] -> |

2730 | (,) [ww1_s4HX ww2_s4HY]; |

2731 | }; |

2732 | |

2733 | Unboxed.$trModule3 :: GHC.Types.TrName |

2734 | [GblId, Caf=NoCafRefs, Str=m1, Unf=OtherCon []] = |

2735 | CCS_DONT_CARE GHC.Types.TrNameS! [Unboxed.$trModule4]; |

2736 | |

2737 | Unboxed.$trModule1 :: GHC.Types.TrName |

2738 | [GblId, Caf=NoCafRefs, Str=m1, Unf=OtherCon []] = |

2739 | CCS_DONT_CARE GHC.Types.TrNameS! [Unboxed.$trModule2]; |

2740 | |

2741 | Unboxed.$trModule :: GHC.Types.Module |

2742 | [GblId, Caf=NoCafRefs, Str=m, Unf=OtherCon []] = |

2743 | CCS_DONT_CARE GHC.Types.Module! [Unboxed.$trModule3 |

2744 | Unboxed.$trModule1]; |

2745 | |

2746 | $krep_r4AA :: GHC.Types.KindRep |

2747 | [GblId, Caf=NoCafRefs, Str=m1, Unf=OtherCon []] = |

2748 | CCS_DONT_CARE GHC.Types.KindRepTyConApp! [GHC.Types.$tcInt |

2749 | GHC.Types.[]]; |

2750 | |

2751 | $krep1_r4AB :: GHC.Types.KindRep |

2752 | [GblId, Caf=NoCafRefs, Str=m2, Unf=OtherCon []] = |

2753 | CCS_DONT_CARE GHC.Types.KindRepVar! [1#]; |

2754 | |

2755 | $krep2_r4AC :: GHC.Types.KindRep |

2756 | [GblId, Caf=NoCafRefs, Str=m2, Unf=OtherCon []] = |

2757 | CCS_DONT_CARE GHC.Types.KindRepVar! [0#]; |

2758 | |

2759 | Unboxed.$tcDigit2 :: GHC.Prim.Addr# |

2760 | [GblId, Caf=NoCafRefs, Unf=OtherCon []] = |

2761 | "Digit"#; |

2762 | |

2763 | Unboxed.$tcDigit1 :: GHC.Types.TrName |

2764 | [GblId, Caf=NoCafRefs, Str=m1, Unf=OtherCon []] = |

2765 | CCS_DONT_CARE GHC.Types.TrNameS! [Unboxed.$tcDigit2]; |

2766 | |

2767 | Unboxed.$tcDigit :: GHC.Types.TyCon |

2768 | [GblId, Caf=NoCafRefs, Str=m, Unf=OtherCon []] = |

2769 | CCS_DONT_CARE GHC.Types.TyCon! [14636189114014665057## |

2770 | 3244156513758390385## |

2771 | Unboxed.$trModule |

2772 | Unboxed.$tcDigit1 |

2773 | 0# |

2774 | GHC.Types.krep$*Arr*]; |

2775 | |

2776 | $krep3_r4AD :: [GHC.Types.KindRep] |

2777 | [GblId, Caf=NoCafRefs, Str=m2, Unf=OtherCon []] = |

2778 | CCS_DONT_CARE :! [$krep2_r4AC GHC.Types.[]]; |

2779 | |

2780 | $krep4_r4AE :: GHC.Types.KindRep |

2781 | [GblId, Caf=NoCafRefs, Str=m1, Unf=OtherCon []] = |

2782 | CCS_DONT_CARE GHC.Types.KindRepTyConApp! [Unboxed.$tcDigit |

2783 | $krep3_r4AD]; |

2784 | |

2785 | Unboxed.$tc'One1 [InlPrag=NOUSERINLINE[~]] :: GHC.Types.KindRep |

2786 | [GblId, Caf=NoCafRefs, Str=m4, Unf=OtherCon []] = |

2787 | CCS_DONT_CARE GHC.Types.KindRepFun! [$krep2_r4AC $krep4_r4AE]; |

2788 | |

2789 | Unboxed.$tc'One3 :: GHC.Prim.Addr# |

2790 | [GblId, Caf=NoCafRefs, Unf=OtherCon []] = |

2791 | "'One"#; |

2792 | |

2793 | Unboxed.$tc'One2 :: GHC.Types.TrName |

2794 | [GblId, Caf=NoCafRefs, Str=m1, Unf=OtherCon []] = |

2795 | CCS_DONT_CARE GHC.Types.TrNameS! [Unboxed.$tc'One3]; |

2796 | |

2797 | Unboxed.$tc'One :: GHC.Types.TyCon |

2798 | [GblId, Caf=NoCafRefs, Str=m, Unf=OtherCon []] = |

2799 | CCS_DONT_CARE GHC.Types.TyCon! [13145429465336945561## |

2800 | 1951529563298898057## |

2801 | Unboxed.$trModule |

2802 | Unboxed.$tc'One2 |

2803 | 1# |

2804 | Unboxed.$tc'One1]; |

2805 | |

2806 | Unboxed.$tc'Two1 [InlPrag=NOUSERINLINE[~]] :: GHC.Types.KindRep |

2807 | [GblId, Caf=NoCafRefs, Str=m4, Unf=OtherCon []] = |

2808 | CCS_DONT_CARE GHC.Types.KindRepFun! [$krep2_r4AC Unboxed.$tc'One1]; |

2809 | |

2810 | Unboxed.$tc'Two3 :: GHC.Prim.Addr# |

2811 | [GblId, Caf=NoCafRefs, Unf=OtherCon []] = |

2812 | "'Two"#; |

2813 | |

2814 | Unboxed.$tc'Two2 :: GHC.Types.TrName |

2815 | [GblId, Caf=NoCafRefs, Str=m1, Unf=OtherCon []] = |

2816 | CCS_DONT_CARE GHC.Types.TrNameS! [Unboxed.$tc'Two3]; |

2817 | |

2818 | Unboxed.$tc'Two :: GHC.Types.TyCon |

2819 | [GblId, Caf=NoCafRefs, Str=m, Unf=OtherCon []] = |

2820 | CCS_DONT_CARE GHC.Types.TyCon! [3245166009349240472## |

2821 | 15678821682105395784## |

2822 | Unboxed.$trModule |

2823 | Unboxed.$tc'Two2 |

2824 | 1# |

2825 | Unboxed.$tc'Two1]; |

2826 | |

2827 | Unboxed.$tc'Three1 [InlPrag=NOUSERINLINE[~]] :: GHC.Types.KindRep |

2828 | [GblId, Caf=NoCafRefs, Str=m4, Unf=OtherCon []] = |

2829 | CCS_DONT_CARE GHC.Types.KindRepFun! [$krep2_r4AC Unboxed.$tc'Two1]; |

2830 | |

2831 | Unboxed.$tc'Three3 :: GHC.Prim.Addr# |

2832 | [GblId, Caf=NoCafRefs, Unf=OtherCon []] = |

2833 | "'Three"#; |

2834 | |

2835 | Unboxed.$tc'Three2 :: GHC.Types.TrName |

2836 | [GblId, Caf=NoCafRefs, Str=m1, Unf=OtherCon []] = |

2837 | CCS_DONT_CARE GHC.Types.TrNameS! [Unboxed.$tc'Three3]; |

2838 | |

2839 | Unboxed.$tc'Three :: GHC.Types.TyCon |

2840 | [GblId, Caf=NoCafRefs, Str=m, Unf=OtherCon []] = |

2841 | CCS_DONT_CARE GHC.Types.TyCon! [10539477579313313060## |

2842 | 9287867415363315468## |

2843 | Unboxed.$trModule |

2844 | Unboxed.$tc'Three2 |

2845 | 1# |

2846 | Unboxed.$tc'Three1]; |

2847 | |

2848 | Unboxed.$tc'Four1 [InlPrag=NOUSERINLINE[~]] :: GHC.Types.KindRep |

2849 | [GblId, Caf=NoCafRefs, Str=m4, Unf=OtherCon []] = |

2850 | CCS_DONT_CARE GHC.Types.KindRepFun! [$krep2_r4AC |

2851 | Unboxed.$tc'Three1]; |

2852 | |

2853 | Unboxed.$tc'Four3 :: GHC.Prim.Addr# |

2854 | [GblId, Caf=NoCafRefs, Unf=OtherCon []] = |

2855 | "'Four"#; |

2856 | |

2857 | Unboxed.$tc'Four2 :: GHC.Types.TrName |

2858 | [GblId, Caf=NoCafRefs, Str=m1, Unf=OtherCon []] = |

2859 | CCS_DONT_CARE GHC.Types.TrNameS! [Unboxed.$tc'Four3]; |

2860 | |

2861 | Unboxed.$tc'Four :: GHC.Types.TyCon |

2862 | [GblId, Caf=NoCafRefs, Str=m, Unf=OtherCon []] = |

2863 | CCS_DONT_CARE GHC.Types.TyCon! [8412709199749071934## |

2864 | 1780562435450824923## |

2865 | Unboxed.$trModule |

2866 | Unboxed.$tc'Four2 |

2867 | 1# |

2868 | Unboxed.$tc'Four1]; |

2869 | |

2870 | $krep5_r4AF :: [GHC.Types.KindRep] |

2871 | [GblId, Caf=NoCafRefs, Str=m2, Unf=OtherCon []] = |

2872 | CCS_DONT_CARE :! [$krep1_r4AB GHC.Types.[]]; |

2873 | |

2874 | $krep6_r4AG :: GHC.Types.KindRep |

2875 | [GblId, Caf=NoCafRefs, Str=m1, Unf=OtherCon []] = |

2876 | CCS_DONT_CARE GHC.Types.KindRepTyConApp! [Unboxed.$tcDigit |

2877 | $krep5_r4AF]; |

2878 | |

2879 | Unboxed.$tcNode2 :: GHC.Prim.Addr# |

2880 | [GblId, Caf=NoCafRefs, Unf=OtherCon []] = |

2881 | "Node"#; |

2882 | |

2883 | Unboxed.$tcNode1 :: GHC.Types.TrName |

2884 | [GblId, Caf=NoCafRefs, Str=m1, Unf=OtherCon []] = |

2885 | CCS_DONT_CARE GHC.Types.TrNameS! [Unboxed.$tcNode2]; |

2886 | |

2887 | Unboxed.$tcNode :: GHC.Types.TyCon |

2888 | [GblId, Caf=NoCafRefs, Str=m, Unf=OtherCon []] = |

2889 | CCS_DONT_CARE GHC.Types.TyCon! [14310021920068471419## |

2890 | 7752484679340451626## |

2891 | Unboxed.$trModule |

2892 | Unboxed.$tcNode1 |

2893 | 0# |

2894 | GHC.Types.krep$*->*->*]; |

2895 | |

2896 | $krep7_r4AH :: [GHC.Types.KindRep] |

2897 | [GblId, Caf=NoCafRefs, Str=m2, Unf=OtherCon []] = |

2898 | CCS_DONT_CARE :! [$krep2_r4AC $krep5_r4AF]; |

2899 | |

2900 | $krep8_r4AI :: GHC.Types.KindRep |

2901 | [GblId, Caf=NoCafRefs, Str=m1, Unf=OtherCon []] = |

2902 | CCS_DONT_CARE GHC.Types.KindRepTyConApp! [Unboxed.$tcNode |

2903 | $krep7_r4AH]; |

2904 | |

2905 | $krep9_r4AJ :: GHC.Types.KindRep |

2906 | [GblId, Caf=NoCafRefs, Str=m4, Unf=OtherCon []] = |

2907 | CCS_DONT_CARE GHC.Types.KindRepFun! [$krep1_r4AB $krep8_r4AI]; |

2908 | |

2909 | $krep10_r4AK :: GHC.Types.KindRep |

2910 | [GblId, Caf=NoCafRefs, Str=m4, Unf=OtherCon []] = |

2911 | CCS_DONT_CARE GHC.Types.KindRepFun! [$krep1_r4AB $krep9_r4AJ]; |

2912 | |

2913 | Unboxed.$tc'Node1 [InlPrag=NOUSERINLINE[~]] :: GHC.Types.KindRep |

2914 | [GblId, Caf=NoCafRefs, Str=m4, Unf=OtherCon []] = |

2915 | CCS_DONT_CARE GHC.Types.KindRepFun! [$krep2_r4AC $krep10_r4AK]; |

2916 | |

2917 | Unboxed.$tc'Node6 :: GHC.Prim.Addr# |

2918 | [GblId, Caf=NoCafRefs, Unf=OtherCon []] = |

2919 | "'Node2"#; |

2920 | |

2921 | Unboxed.$tc'Node5 :: GHC.Types.TrName |

2922 | [GblId, Caf=NoCafRefs, Str=m1, Unf=OtherCon []] = |

2923 | CCS_DONT_CARE GHC.Types.TrNameS! [Unboxed.$tc'Node6]; |

2924 | |

2925 | Unboxed.$tc'Node2 :: GHC.Types.TyCon |

2926 | [GblId, Caf=NoCafRefs, Str=m, Unf=OtherCon []] = |

2927 | CCS_DONT_CARE GHC.Types.TyCon! [16188463194491579684## |

2928 | 8521110775579450636## |

2929 | Unboxed.$trModule |

2930 | Unboxed.$tc'Node5 |

2931 | 2# |

2932 | Unboxed.$tc'Node1]; |

2933 | |

2934 | $krep11_r4AL :: GHC.Types.KindRep |

2935 | [GblId, Caf=NoCafRefs, Str=m4, Unf=OtherCon []] = |

2936 | CCS_DONT_CARE GHC.Types.KindRepFun! [$krep1_r4AB $krep10_r4AK]; |

2937 | |

2938 | Unboxed.$tc'Node7 [InlPrag=NOUSERINLINE[~]] :: GHC.Types.KindRep |

2939 | [GblId, Caf=NoCafRefs, Str=m4, Unf=OtherCon []] = |

2940 | CCS_DONT_CARE GHC.Types.KindRepFun! [$krep2_r4AC $krep11_r4AL]; |

2941 | |

2942 | Unboxed.$tc'Node9 :: GHC.Prim.Addr# |

2943 | [GblId, Caf=NoCafRefs, Unf=OtherCon []] = |

2944 | "'Node3"#; |

2945 | |

2946 | Unboxed.$tc'Node8 :: GHC.Types.TrName |

2947 | [GblId, Caf=NoCafRefs, Str=m1, Unf=OtherCon []] = |

2948 | CCS_DONT_CARE GHC.Types.TrNameS! [Unboxed.$tc'Node9]; |

2949 | |

2950 | Unboxed.$tc'Node3 :: GHC.Types.TyCon |

2951 | [GblId, Caf=NoCafRefs, Str=m, Unf=OtherCon []] = |

2952 | CCS_DONT_CARE GHC.Types.TyCon! [5824654492323244063## |

2953 | 13374226018913758109## |

2954 | Unboxed.$trModule |

2955 | Unboxed.$tc'Node8 |

2956 | 2# |

2957 | Unboxed.$tc'Node7]; |

2958 | |

2959 | Unboxed.$tcFingerTree2 :: GHC.Prim.Addr# |

2960 | [GblId, Caf=NoCafRefs, Unf=OtherCon []] = |

2961 | "FingerTree"#; |

2962 | |

2963 | Unboxed.$tcFingerTree1 :: GHC.Types.TrName |

2964 | [GblId, Caf=NoCafRefs, Str=m1, Unf=OtherCon []] = |

2965 | CCS_DONT_CARE GHC.Types.TrNameS! [Unboxed.$tcFingerTree2]; |

2966 | |

2967 | Unboxed.$tcFingerTree :: GHC.Types.TyCon |

2968 | [GblId, Caf=NoCafRefs, Str=m, Unf=OtherCon []] = |

2969 | CCS_DONT_CARE GHC.Types.TyCon! [16822976935429065404## |

2970 | 1656303194987393222## |

2971 | Unboxed.$trModule |

2972 | Unboxed.$tcFingerTree1 |

2973 | 0# |

2974 | GHC.Types.krep$*->*->*]; |

2975 | |

2976 | Unboxed.$tc'Empty1 [InlPrag=NOUSERINLINE[~]] :: GHC.Types.KindRep |

2977 | [GblId, Caf=NoCafRefs, Str=m1, Unf=OtherCon []] = |

2978 | CCS_DONT_CARE GHC.Types.KindRepTyConApp! [Unboxed.$tcFingerTree |

2979 | $krep7_r4AH]; |

2980 | |

2981 | Unboxed.$tc'Empty3 :: GHC.Prim.Addr# |

2982 | [GblId, Caf=NoCafRefs, Unf=OtherCon []] = |

2983 | "'Empty"#; |

2984 | |

2985 | Unboxed.$tc'Empty2 :: GHC.Types.TrName |

2986 | [GblId, Caf=NoCafRefs, Str=m1, Unf=OtherCon []] = |

2987 | CCS_DONT_CARE GHC.Types.TrNameS! [Unboxed.$tc'Empty3]; |

2988 | |

2989 | Unboxed.$tc'Empty :: GHC.Types.TyCon |

2990 | [GblId, Caf=NoCafRefs, Str=m, Unf=OtherCon []] = |

2991 | CCS_DONT_CARE GHC.Types.TyCon! [8016004449277268857## |

2992 | 8175871094911629858## |

2993 | Unboxed.$trModule |

2994 | Unboxed.$tc'Empty2 |

2995 | 2# |

2996 | Unboxed.$tc'Empty1]; |

2997 | |

2998 | Unboxed.$tc'Single1 [InlPrag=NOUSERINLINE[~]] :: GHC.Types.KindRep |

2999 | [GblId, Caf=NoCafRefs, Str=m4, Unf=OtherCon []] = |

3000 | CCS_DONT_CARE GHC.Types.KindRepFun! [$krep1_r4AB |

3001 | Unboxed.$tc'Empty1]; |

3002 | |

3003 | Unboxed.$tc'Single3 :: GHC.Prim.Addr# |

3004 | [GblId, Caf=NoCafRefs, Unf=OtherCon []] = |

3005 | "'Single"#; |

3006 | |

3007 | Unboxed.$tc'Single2 :: GHC.Types.TrName |

3008 | [GblId, Caf=NoCafRefs, Str=m1, Unf=OtherCon []] = |

3009 | CCS_DONT_CARE GHC.Types.TrNameS! [Unboxed.$tc'Single3]; |

3010 | |

3011 | Unboxed.$tc'Single :: GHC.Types.TyCon |

3012 | [GblId, Caf=NoCafRefs, Str=m, Unf=OtherCon []] = |

3013 | CCS_DONT_CARE GHC.Types.TyCon! [690857965741511270## |

3014 | 16411512555119301998## |

3015 | Unboxed.$trModule |

3016 | Unboxed.$tc'Single2 |

3017 | 2# |

3018 | Unboxed.$tc'Single1]; |

3019 | |

3020 | $krep12_r4AM :: GHC.Types.KindRep |

3021 | [GblId, Caf=NoCafRefs, Str=m4, Unf=OtherCon []] = |

3022 | CCS_DONT_CARE GHC.Types.KindRepFun! [$krep6_r4AG |

3023 | Unboxed.$tc'Empty1]; |

3024 | |

3025 | $krep13_r4AN :: [GHC.Types.KindRep] |

3026 | [GblId, Caf=NoCafRefs, Str=m2, Unf=OtherCon []] = |

3027 | CCS_DONT_CARE :! [$krep8_r4AI GHC.Types.[]]; |

3028 | |

3029 | $krep14_r4AO :: [GHC.Types.KindRep] |

3030 | [GblId, Caf=NoCafRefs, Str=m2, Unf=OtherCon []] = |

3031 | CCS_DONT_CARE :! [$krep2_r4AC $krep13_r4AN]; |

3032 | |

3033 | $krep15_r4AP :: GHC.Types.KindRep |

3034 | [GblId, Caf=NoCafRefs, Str=m1, Unf=OtherCon []] = |

3035 | CCS_DONT_CARE GHC.Types.KindRepTyConApp! [Unboxed.$tcFingerTree |

3036 | $krep14_r4AO]; |

3037 | |

3038 | $krep16_r4AQ :: GHC.Types.KindRep |

3039 | [GblId, Caf=NoCafRefs, Str=m4, Unf=OtherCon []] = |

3040 | CCS_DONT_CARE GHC.Types.KindRepFun! [$krep15_r4AP $krep12_r4AM]; |

3041 | |

3042 | $krep17_r4AR :: GHC.Types.KindRep |

3043 | [GblId, Caf=NoCafRefs, Str=m4, Unf=OtherCon []] = |

3044 | CCS_DONT_CARE GHC.Types.KindRepFun! [$krep6_r4AG $krep16_r4AQ]; |

3045 | |

3046 | Unboxed.$tc'Deep1 [InlPrag=NOUSERINLINE[~]] :: GHC.Types.KindRep |

3047 | [GblId, Caf=NoCafRefs, Str=m4, Unf=OtherCon []] = |

3048 | CCS_DONT_CARE GHC.Types.KindRepFun! [$krep2_r4AC $krep17_r4AR]; |

3049 | |

3050 | Unboxed.$tc'Deep3 :: GHC.Prim.Addr# |

3051 | [GblId, Caf=NoCafRefs, Unf=OtherCon []] = |

3052 | "'Deep"#; |

3053 | |

3054 | Unboxed.$tc'Deep2 :: GHC.Types.TrName |

3055 | [GblId, Caf=NoCafRefs, Str=m1, Unf=OtherCon []] = |

3056 | CCS_DONT_CARE GHC.Types.TrNameS! [Unboxed.$tc'Deep3]; |

3057 | |

3058 | Unboxed.$tc'Deep :: GHC.Types.TyCon |

3059 | [GblId, Caf=NoCafRefs, Str=m, Unf=OtherCon []] = |

3060 | CCS_DONT_CARE GHC.Types.TyCon! [17051504987554028038## |

3061 | 17660574047002347877## |

3062 | Unboxed.$trModule |

3063 | Unboxed.$tc'Deep2 |

3064 | 2# |

3065 | Unboxed.$tc'Deep1]; |

3066 | |

3067 | Unboxed.$tcSize2 :: GHC.Prim.Addr# |

3068 | [GblId, Caf=NoCafRefs, Unf=OtherCon []] = |

3069 | "Size"#; |

3070 | |

3071 | Unboxed.$tcSize1 :: GHC.Types.TrName |

3072 | [GblId, Caf=NoCafRefs, Str=m1, Unf=OtherCon []] = |

3073 | CCS_DONT_CARE GHC.Types.TrNameS! [Unboxed.$tcSize2]; |

3074 | |

3075 | Unboxed.$tcSize :: GHC.Types.TyCon |

3076 | [GblId, Caf=NoCafRefs, Str=m, Unf=OtherCon []] = |

3077 | CCS_DONT_CARE GHC.Types.TyCon! [1626577040394917353## |

3078 | 321012077059614582## |

3079 | Unboxed.$trModule |

3080 | Unboxed.$tcSize1 |

3081 | 0# |

3082 | GHC.Types.krep$*]; |

3083 | |

3084 | $krep18_r4AS :: GHC.Types.KindRep |

3085 | [GblId, Caf=NoCafRefs, Str=m1, Unf=OtherCon []] = |

3086 | CCS_DONT_CARE GHC.Types.KindRepTyConApp! [Unboxed.$tcSize |

3087 | GHC.Types.[]]; |

3088 | |

3089 | Unboxed.$tc'Size1 [InlPrag=NOUSERINLINE[~]] :: GHC.Types.KindRep |

3090 | [GblId, Caf=NoCafRefs, Str=m4, Unf=OtherCon []] = |

3091 | CCS_DONT_CARE GHC.Types.KindRepFun! [$krep_r4AA $krep18_r4AS]; |

3092 | |

3093 | Unboxed.$tc'Size3 :: GHC.Prim.Addr# |

3094 | [GblId, Caf=NoCafRefs, Unf=OtherCon []] = |

3095 | "'Size"#; |

3096 | |

3097 | Unboxed.$tc'Size2 :: GHC.Types.TrName |

3098 | [GblId, Caf=NoCafRefs, Str=m1, Unf=OtherCon []] = |

3099 | CCS_DONT_CARE GHC.Types.TrNameS! [Unboxed.$tc'Size3]; |

3100 | |

3101 | Unboxed.$tc'Size :: GHC.Types.TyCon |

3102 | [GblId, Caf=NoCafRefs, Str=m, Unf=OtherCon []] = |

3103 | CCS_DONT_CARE GHC.Types.TyCon! [17310009312016945755## |

3104 | 9442420112108172298## |

3105 | Unboxed.$trModule |

3106 | Unboxed.$tc'Size2 |

3107 | 0# |

3108 | Unboxed.$tc'Size1]; |

3109 | |

3110 | Unboxed.Empty :: forall v a. Unboxed.FingerTree v a |

3111 | [GblId[DataCon], Caf=NoCafRefs, Unf=OtherCon []] = |

3112 | CCS_DONT_CARE Unboxed.Empty! []; |

3113 | |

3114 | Unboxed.Single :: forall v a. a -> Unboxed.FingerTree v a |

3115 | [GblId[DataCon], |

3116 | Arity=1, |

3117 | Caf=NoCafRefs, |

3118 | Str=<L,U>m2, |

3119 | Unf=OtherCon []] = |

3120 | [] \r [eta_B1] Unboxed.Single [eta_B1]; |

3121 | |

3122 | Unboxed.Deep |

3123 | :: forall v a. |

3124 | v |

3125 | -> Unboxed.Digit a |

3126 | -> Unboxed.FingerTree v (Unboxed.Node v a) |

3127 | -> Unboxed.Digit a |

3128 | -> Unboxed.FingerTree v a |

3129 | [GblId[DataCon], |

3130 | Arity=4, |

3131 | Caf=NoCafRefs, |

3132 | Str=<L,U><L,U><L,U><L,U>m3, |

3133 | Unf=OtherCon []] = |

3134 | [] \r [eta_B4 eta_B3 eta_B2 eta_B1] |

3135 | Unboxed.Deep [eta_B4 eta_B3 eta_B2 eta_B1]; |

3136 | |

3137 | Unboxed.Node2 :: forall v a. v -> a -> a -> Unboxed.Node v a |

3138 | [GblId[DataCon], |

3139 | Arity=3, |

3140 | Caf=NoCafRefs, |

3141 | Str=<L,U><L,U><L,U>m1, |

3142 | Unf=OtherCon []] = |

3143 | [] \r [eta_B3 eta_B2 eta_B1] Unboxed.Node2 [eta_B3 eta_B2 eta_B1]; |

3144 | |

3145 | Unboxed.Node3 :: forall v a. v -> a -> a -> a -> Unboxed.Node v a |

3146 | [GblId[DataCon], |

3147 | Arity=4, |

3148 | Caf=NoCafRefs, |

3149 | Str=<L,U><L,U><L,U><L,U>m2, |

3150 | Unf=OtherCon []] = |

3151 | [] \r [eta_B4 eta_B3 eta_B2 eta_B1] |

3152 | Unboxed.Node3 [eta_B4 eta_B3 eta_B2 eta_B1]; |

3153 | |

3154 | Unboxed.One :: forall a. a -> Unboxed.Digit a |

3155 | [GblId[DataCon], |

3156 | Arity=1, |

3157 | Caf=NoCafRefs, |

3158 | Str=<L,U>m1, |

3159 | Unf=OtherCon []] = |

3160 | [] \r [eta_B1] Unboxed.One [eta_B1]; |

3161 | |

3162 | Unboxed.Two :: forall a. a -> a -> Unboxed.Digit a |

3163 | [GblId[DataCon], |

3164 | Arity=2, |

3165 | Caf=NoCafRefs, |

3166 | Str=<L,U><L,U>m2, |

3167 | Unf=OtherCon []] = |

3168 | [] \r [eta_B2 eta_B1] Unboxed.Two [eta_B2 eta_B1]; |

3169 | |

3170 | Unboxed.Three :: forall a. a -> a -> a -> Unboxed.Digit a |

3171 | [GblId[DataCon], |

3172 | Arity=3, |

3173 | Caf=NoCafRefs, |

3174 | Str=<L,U><L,U><L,U>m3, |

3175 | Unf=OtherCon []] = |

3176 | [] \r [eta_B3 eta_B2 eta_B1] Unboxed.Three [eta_B3 eta_B2 eta_B1]; |

3177 | |

3178 | Unboxed.Four :: forall a. a -> a -> a -> a -> Unboxed.Digit a |

3179 | [GblId[DataCon], |

3180 | Arity=4, |

3181 | Caf=NoCafRefs, |

3182 | Str=<L,U><L,U><L,U><L,U>m4, |

3183 | Unf=OtherCon []] = |

3184 | [] \r [eta_B4 eta_B3 eta_B2 eta_B1] |

3185 | Unboxed.Four [eta_B4 eta_B3 eta_B2 eta_B1]; |

3186 |