# Ticket #5522: partial.core.2.z6

File partial.core.2.z6, 65.7 KB (added by , 5 years ago) |
---|

Line | |
---|---|

1 | |

2 | ==================== Occurrence analysis ==================== |

3 | lvl_scn :: GHC.Types.Int |

4 | [LclId, Str=DmdType m] |

5 | lvl_scn = GHC.Types.I# 1 |

6 | |

7 | lvl_scm [Occ=OnceL] :: [GHC.Types.Int] |

8 | [LclId, Str=DmdType] |

9 | lvl_scm = |

10 | GHC.Types.: @ GHC.Types.Int lvl_scn (GHC.Types.[] @ GHC.Types.Int) |

11 | |

12 | lvl_scp :: GHC.Types.Int |

13 | [LclId, Str=DmdType m] |

14 | lvl_scp = GHC.Types.I# 2 |

15 | |

16 | lvl_sco :: [GHC.Types.Int] |

17 | [LclId, Str=DmdType] |

18 | lvl_sco = |

19 | GHC.Types.: @ GHC.Types.Int lvl_scp (GHC.Types.[] @ GHC.Types.Int) |

20 | |

21 | lvl_scr :: GHC.Types.Int |

22 | [LclId, Str=DmdType m] |

23 | lvl_scr = GHC.Types.I# 3 |

24 | |

25 | lvl_scq :: [GHC.Types.Int] |

26 | [LclId, Str=DmdType] |

27 | lvl_scq = |

28 | GHC.Types.: @ GHC.Types.Int lvl_scr (GHC.Types.[] @ GHC.Types.Int) |

29 | |

30 | lvl_sct :: GHC.Types.Int |

31 | [LclId, Str=DmdType m] |

32 | lvl_sct = GHC.Types.I# 4 |

33 | |

34 | lvl_scs :: [GHC.Types.Int] |

35 | [LclId, Str=DmdType] |

36 | lvl_scs = |

37 | GHC.Types.: @ GHC.Types.Int lvl_sct (GHC.Types.[] @ GHC.Types.Int) |

38 | |

39 | lvl_scv :: GHC.Types.Int |

40 | [LclId, Str=DmdType m] |

41 | lvl_scv = GHC.Types.I# 5 |

42 | |

43 | lvl_scu :: [GHC.Types.Int] |

44 | [LclId, Str=DmdType] |

45 | lvl_scu = |

46 | GHC.Types.: @ GHC.Types.Int lvl_scv (GHC.Types.[] @ GHC.Types.Int) |

47 | |

48 | Rec { |

49 | go_abJ [Occ=LoopBreaker] :: [GHC.Types.Int] -> [GHC.Types.Int] |

50 | [LclId, Arity=1, Str=DmdType S] |

51 | go_abJ = |

52 | \ (ds_abK [Occ=Once!] :: [GHC.Types.Int]) -> |

53 | case ds_abK of _ { |

54 | [] -> GHC.Types.[] @ GHC.Types.Int; |

55 | : y_abO [Dmd=Just D(T)] ys_abP [Occ=Once*, Dmd=Just L] -> |

56 | letrec { |

57 | $sgo_sgj [Occ=LoopBreaker] |

58 | :: GHC.Prim.Int# -> [GHC.Types.Int] -> [GHC.Types.Int] |

59 | [LclId, Arity=2, Str=DmdType LL] |

60 | $sgo_sgj = |

61 | \ (sc_sfr :: GHC.Prim.Int#) |

62 | (sc_sfs [Occ=Once*] :: [GHC.Types.Int]) -> |

63 | letrec { |

64 | $sgo_sgk [Occ=LoopBreaker] |

65 | :: GHC.Prim.Int# -> [GHC.Types.Int] -> [GHC.Types.Int] |

66 | [LclId, Arity=2, Str=DmdType LL] |

67 | $sgo_sgk = |

68 | \ (sc_sg1 [Occ=OnceL] :: GHC.Prim.Int#) |

69 | (sc_sg2 [Occ=Once*] :: [GHC.Types.Int]) -> |

70 | letrec { |

71 | go_Xdb [Occ=LoopBreaker] :: [GHC.Types.Int] -> [GHC.Types.Int] |

72 | [LclId, Arity=1, Str=DmdType S] |

73 | go_Xdb = |

74 | \ (ds_Xcs [Occ=Once!] :: [GHC.Types.Int]) -> |

75 | case ds_Xcs of _ { |

76 | [] -> GHC.Types.[] @ GHC.Types.Int; |

77 | : y_Xcy [Occ=OnceL!, Dmd=Just D(T)] |

78 | ys_XcA [Occ=Once*, Dmd=Just L] -> |

79 | letrec { |

80 | go_Xdn [Occ=LoopBreaker] :: [GHC.Types.Int] -> [GHC.Types.Int] |

81 | [LclId, Arity=1, Str=DmdType S] |

82 | go_Xdn = |

83 | \ (ds_Xdq [Occ=Once!] :: [GHC.Types.Int]) -> |

84 | case ds_Xdq of _ { |

85 | [] -> GHC.Types.[] @ GHC.Types.Int; |

86 | : y_XcC [Occ=Once!, Dmd=Just D(T)] |

87 | ys_XcE [Occ=Once*, Dmd=Just L] -> |

88 | let { |

89 | lvl_scw [Occ=OnceL, Dmd=Just D(T)] :: GHC.Types.Int |

90 | [LclId, Str=DmdType] |

91 | lvl_scw = |

92 | case y_abO |

93 | of _ { GHC.Types.I# x_abx [Occ=Once, Dmd=Just L] -> |

94 | case y_Xcy |

95 | of _ { GHC.Types.I# y_XcI [Occ=Once, Dmd=Just L] -> |

96 | case y_XcC |

97 | of _ { GHC.Types.I# y_XcU [Occ=Once, Dmd=Just L] -> |

98 | GHC.Types.I# |

99 | (GHC.Prim.+# |

100 | (GHC.Prim.+# |

101 | (GHC.Prim.+# (GHC.Prim.+# x_abx sc_sfr) sc_sg1) |

102 | y_XcI) |

103 | y_XcU) |

104 | } |

105 | } |

106 | } } in |

107 | letrec { |

108 | go_Xcx [Occ=LoopBreaker] |

109 | :: [GHC.Types.Int] -> [GHC.Types.Int] |

110 | [LclId, Arity=1, Str=DmdType S] |

111 | go_Xcx = |

112 | \ (ds_Xcz [Occ=Once!] :: [GHC.Types.Int]) -> |

113 | case ds_Xcz of _ { |

114 | [] -> GHC.Types.[] @ GHC.Types.Int; |

115 | : y_XcF [Occ=Once, Dmd=Just D(L)] |

116 | ys_XcH [Occ=Once, Dmd=Just L] -> |

117 | GHC.Types.: |

118 | @ GHC.Types.Int |

119 | (GHC.Base.plusInt lvl_scw y_XcF) |

120 | (go_Xcx ys_XcH) |

121 | }; } in |

122 | case go_Xcx lvl_scu of _ { |

123 | [] -> go_Xdn ys_XcE; |

124 | : x_abV [Occ=Once, Dmd=Just L] |

125 | xs_abW [Occ=Once, Dmd=Just L] -> |

126 | GHC.Types.: |

127 | @ GHC.Types.Int |

128 | x_abV |

129 | (GHC.Base.++ @ GHC.Types.Int xs_abW (go_Xdn ys_XcE)) |

130 | } |

131 | }; } in |

132 | case go_Xdn lvl_scs of _ { |

133 | [] -> go_Xdb ys_XcA; |

134 | : x_abV [Occ=Once, Dmd=Just L] xs_abW [Occ=Once, Dmd=Just L] -> |

135 | GHC.Types.: |

136 | @ GHC.Types.Int |

137 | x_abV |

138 | (GHC.Base.++ @ GHC.Types.Int xs_abW (go_Xdb ys_XcA)) |

139 | } |

140 | }; } in |

141 | case go_Xdb lvl_scq of _ { |

142 | [] -> go_XcZ sc_sg2; |

143 | : x_abV [Occ=Once, Dmd=Just L] xs_abW [Occ=Once, Dmd=Just L] -> |

144 | GHC.Types.: |

145 | @ GHC.Types.Int |

146 | x_abV |

147 | (GHC.Base.++ @ GHC.Types.Int xs_abW (go_XcZ sc_sg2)) |

148 | }; |

149 | go_XcZ [Occ=LoopBreaker] :: [GHC.Types.Int] -> [GHC.Types.Int] |

150 | [LclId, |

151 | Arity=1, |

152 | Str=DmdType S, |

153 | RULES: "SC:go0" [ALWAYS] |

154 | forall (sc_sg1 :: GHC.Prim.Int#) (sc_sg2 :: [GHC.Types.Int]). |

155 | go_XcZ (GHC.Types.: @ GHC.Types.Int (GHC.Types.I# sc_sg1) sc_sg2) |

156 | = $sgo_sgk sc_sg1 sc_sg2] |

157 | go_XcZ = |

158 | \ (ds_Xd2 [Occ=Once!] :: [GHC.Types.Int]) -> |

159 | case ds_Xd2 of _ { |

160 | [] -> GHC.Types.[] @ GHC.Types.Int; |

161 | : y_Xcu [Dmd=Just D(T)] ys_Xcw [Occ=Once*, Dmd=Just L] -> |

162 | letrec { |

163 | $sgo_sgl [Occ=LoopBreaker] |

164 | :: GHC.Prim.Int# -> [GHC.Types.Int] -> [GHC.Types.Int] |

165 | [LclId, Arity=2, Str=DmdType LL] |

166 | $sgo_sgl = |

167 | \ (sc_sfO [Occ=OnceL] :: GHC.Prim.Int#) |

168 | (sc_sfP [Occ=Once*] :: [GHC.Types.Int]) -> |

169 | letrec { |

170 | go_Xdn [Occ=LoopBreaker] :: [GHC.Types.Int] -> [GHC.Types.Int] |

171 | [LclId, Arity=1, Str=DmdType S] |

172 | go_Xdn = |

173 | \ (ds_Xdq [Occ=Once!] :: [GHC.Types.Int]) -> |

174 | case ds_Xdq of _ { |

175 | [] -> GHC.Types.[] @ GHC.Types.Int; |

176 | : y_XcC [Occ=Once!, Dmd=Just D(T)] |

177 | ys_XcE [Occ=Once*, Dmd=Just L] -> |

178 | let { |

179 | lvl_scw [Occ=OnceL, Dmd=Just D(T)] :: GHC.Types.Int |

180 | [LclId, Str=DmdType] |

181 | lvl_scw = |

182 | case y_abO |

183 | of _ { GHC.Types.I# x_abx [Occ=Once, Dmd=Just L] -> |

184 | case y_Xcu |

185 | of _ { GHC.Types.I# y_Xdr [Occ=Once, Dmd=Just L] -> |

186 | case y_XcC |

187 | of _ { GHC.Types.I# y_XcU [Occ=Once, Dmd=Just L] -> |

188 | GHC.Types.I# |

189 | (GHC.Prim.+# |

190 | (GHC.Prim.+# |

191 | (GHC.Prim.+# (GHC.Prim.+# x_abx sc_sfr) y_Xdr) |

192 | sc_sfO) |

193 | y_XcU) |

194 | } |

195 | } |

196 | } } in |

197 | letrec { |

198 | go_Xcx [Occ=LoopBreaker] |

199 | :: [GHC.Types.Int] -> [GHC.Types.Int] |

200 | [LclId, Arity=1, Str=DmdType S] |

201 | go_Xcx = |

202 | \ (ds_Xcz [Occ=Once!] :: [GHC.Types.Int]) -> |

203 | case ds_Xcz of _ { |

204 | [] -> GHC.Types.[] @ GHC.Types.Int; |

205 | : y_XcF [Occ=Once, Dmd=Just D(L)] |

206 | ys_XcH [Occ=Once, Dmd=Just L] -> |

207 | GHC.Types.: |

208 | @ GHC.Types.Int |

209 | (GHC.Base.plusInt lvl_scw y_XcF) |

210 | (go_Xcx ys_XcH) |

211 | }; } in |

212 | case go_Xcx lvl_scu of _ { |

213 | [] -> go_Xdn ys_XcE; |

214 | : x_abV [Occ=Once, Dmd=Just L] |

215 | xs_abW [Occ=Once, Dmd=Just L] -> |

216 | GHC.Types.: |

217 | @ GHC.Types.Int |

218 | x_abV |

219 | (GHC.Base.++ @ GHC.Types.Int xs_abW (go_Xdn ys_XcE)) |

220 | } |

221 | }; } in |

222 | case go_Xdn lvl_scs of _ { |

223 | [] -> go_Xdb sc_sfP; |

224 | : x_abV [Occ=Once, Dmd=Just L] xs_abW [Occ=Once, Dmd=Just L] -> |

225 | GHC.Types.: |

226 | @ GHC.Types.Int |

227 | x_abV |

228 | (GHC.Base.++ @ GHC.Types.Int xs_abW (go_Xdb sc_sfP)) |

229 | }; |

230 | go_Xdb [Occ=LoopBreaker] :: [GHC.Types.Int] -> [GHC.Types.Int] |

231 | [LclId, |

232 | Arity=1, |

233 | Str=DmdType S, |

234 | RULES: "SC:go0" [ALWAYS] |

235 | forall (sc_sfO :: GHC.Prim.Int#) (sc_sfP :: [GHC.Types.Int]). |

236 | go_Xdb (GHC.Types.: |

237 | @ GHC.Types.Int (GHC.Types.I# sc_sfO) sc_sfP) |

238 | = $sgo_sgl sc_sfO sc_sfP] |

239 | go_Xdb = |

240 | \ (ds_Xcs [Occ=Once!] :: [GHC.Types.Int]) -> |

241 | case ds_Xcs of _ { |

242 | [] -> GHC.Types.[] @ GHC.Types.Int; |

243 | : y_Xcy [Dmd=Just D(T)] ys_XcA [Occ=Once*, Dmd=Just L] -> |

244 | letrec { |

245 | $sgo_sgm [Occ=LoopBreaker] |

246 | :: GHC.Prim.Int# -> [GHC.Types.Int] -> [GHC.Types.Int] |

247 | [LclId, Arity=2, Str=DmdType LL] |

248 | $sgo_sgm = |

249 | \ (sc_sfD [Occ=Once] :: GHC.Prim.Int#) |

250 | (sc_sfE [Occ=Once*] :: [GHC.Types.Int]) -> |

251 | let { |

252 | lvl_scw [Occ=OnceL, Dmd=Just D(T)] :: GHC.Types.Int |

253 | [LclId, Str=DmdType] |

254 | lvl_scw = |

255 | case y_abO |

256 | of _ { GHC.Types.I# x_abx [Occ=Once, Dmd=Just L] -> |

257 | case y_Xcu |

258 | of _ { GHC.Types.I# y_Xdr [Occ=Once, Dmd=Just L] -> |

259 | case y_Xcy |

260 | of _ { GHC.Types.I# y_XcI [Occ=Once, Dmd=Just L] -> |

261 | GHC.Types.I# |

262 | (GHC.Prim.+# |

263 | (GHC.Prim.+# |

264 | (GHC.Prim.+# (GHC.Prim.+# x_abx sc_sfr) y_Xdr) |

265 | y_XcI) |

266 | sc_sfD) |

267 | } |

268 | } |

269 | } } in |

270 | letrec { |

271 | go_Xcx [Occ=LoopBreaker] |

272 | :: [GHC.Types.Int] -> [GHC.Types.Int] |

273 | [LclId, Arity=1, Str=DmdType S] |

274 | go_Xcx = |

275 | \ (ds_Xcz [Occ=Once!] :: [GHC.Types.Int]) -> |

276 | case ds_Xcz of _ { |

277 | [] -> GHC.Types.[] @ GHC.Types.Int; |

278 | : y_XcF [Occ=Once, Dmd=Just D(L)] |

279 | ys_XcH [Occ=Once, Dmd=Just L] -> |

280 | GHC.Types.: |

281 | @ GHC.Types.Int |

282 | (GHC.Base.plusInt lvl_scw y_XcF) |

283 | (go_Xcx ys_XcH) |

284 | }; } in |

285 | case go_Xcx lvl_scu of _ { |

286 | [] -> go_Xdn sc_sfE; |

287 | : x_abV [Occ=Once, Dmd=Just L] |

288 | xs_abW [Occ=Once, Dmd=Just L] -> |

289 | GHC.Types.: |

290 | @ GHC.Types.Int |

291 | x_abV |

292 | (GHC.Base.++ @ GHC.Types.Int xs_abW (go_Xdn sc_sfE)) |

293 | }; |

294 | go_Xdn [Occ=LoopBreaker] :: [GHC.Types.Int] -> [GHC.Types.Int] |

295 | [LclId, |

296 | Arity=1, |

297 | Str=DmdType S, |

298 | RULES: "SC:go0" [ALWAYS] |

299 | forall (sc_sfD :: GHC.Prim.Int#) |

300 | (sc_sfE :: [GHC.Types.Int]). |

301 | go_Xdn (GHC.Types.: |

302 | @ GHC.Types.Int |

303 | (GHC.Types.I# sc_sfD) |

304 | sc_sfE) |

305 | = $sgo_sgm sc_sfD sc_sfE] |

306 | go_Xdn = |

307 | \ (ds_Xdq [Occ=Once!] :: [GHC.Types.Int]) -> |

308 | case ds_Xdq of _ { |

309 | [] -> GHC.Types.[] @ GHC.Types.Int; |

310 | : y_XcC [Occ=Once!, Dmd=Just D(T)] |

311 | ys_XcE [Occ=Once*, Dmd=Just L] -> |

312 | let { |

313 | lvl_scw [Dmd=Just D(T)] :: GHC.Types.Int |

314 | [LclId, Str=DmdType] |

315 | lvl_scw = |

316 | case y_abO |

317 | of _ { GHC.Types.I# x_abx [Occ=Once, Dmd=Just L] -> |

318 | case y_Xcu |

319 | of _ { GHC.Types.I# y_Xdr [Occ=Once, Dmd=Just L] -> |

320 | case y_Xcy |

321 | of _ { GHC.Types.I# y_XcI [Occ=Once, Dmd=Just L] -> |

322 | case y_XcC |

323 | of _ { GHC.Types.I# y_XcU [Occ=Once, Dmd=Just L] -> |

324 | GHC.Types.I# |

325 | (GHC.Prim.+# |

326 | (GHC.Prim.+# |

327 | (GHC.Prim.+# |

328 | (GHC.Prim.+# x_abx sc_sfr) y_Xdr) |

329 | y_XcI) |

330 | y_XcU) |

331 | } |

332 | } |

333 | } |

334 | } } in |

335 | letrec { |

336 | $sgo_sgn [Occ=LoopBreaker] |

337 | :: GHC.Types.Int |

338 | -> [GHC.Types.Int] -> [GHC.Types.Int] |

339 | [LclId, Arity=2, Str=DmdType LL] |

340 | $sgo_sgn = |

341 | \ (sc_sfw [Occ=Once] :: GHC.Types.Int) |

342 | (sc_sfx [Occ=Once] :: [GHC.Types.Int]) -> |

343 | GHC.Types.: |

344 | @ GHC.Types.Int |

345 | (GHC.Base.plusInt lvl_scw sc_sfw) |

346 | (go_Xcx sc_sfx); |

347 | go_Xcx [Occ=LoopBreaker] |

348 | :: [GHC.Types.Int] -> [GHC.Types.Int] |

349 | [LclId, |

350 | Arity=1, |

351 | Str=DmdType S, |

352 | RULES: "SC:go0" [ALWAYS] |

353 | forall (sc_sfw :: GHC.Types.Int) |

354 | (sc_sfx :: [GHC.Types.Int]). |

355 | go_Xcx (GHC.Types.: |

356 | @ GHC.Types.Int sc_sfw sc_sfx) |

357 | = $sgo_sgn sc_sfw sc_sfx] |

358 | go_Xcx = |

359 | \ (ds_Xcz [Occ=Once!] :: [GHC.Types.Int]) -> |

360 | case ds_Xcz of _ { |

361 | [] -> GHC.Types.[] @ GHC.Types.Int; |

362 | : y_XcF [Occ=Once, Dmd=Just D(L)] |

363 | ys_XcH [Occ=Once, Dmd=Just L] -> |

364 | GHC.Types.: |

365 | @ GHC.Types.Int |

366 | (GHC.Base.plusInt lvl_scw y_XcF) |

367 | (go_Xcx ys_XcH) |

368 | }; } in |

369 | case go_Xcx lvl_scu of _ { |

370 | [] -> go_Xdn ys_XcE; |

371 | : x_abV [Occ=Once, Dmd=Just L] |

372 | xs_abW [Occ=Once, Dmd=Just L] -> |

373 | GHC.Types.: |

374 | @ GHC.Types.Int |

375 | x_abV |

376 | (GHC.Base.++ |

377 | @ GHC.Types.Int xs_abW (go_Xdn ys_XcE)) |

378 | } |

379 | }; } in |

380 | case go_Xdn lvl_scs of _ { |

381 | [] -> go_Xdb ys_XcA; |

382 | : x_abV [Occ=Once, Dmd=Just L] xs_abW [Occ=Once, Dmd=Just L] -> |

383 | GHC.Types.: |

384 | @ GHC.Types.Int |

385 | x_abV |

386 | (GHC.Base.++ @ GHC.Types.Int xs_abW (go_Xdb ys_XcA)) |

387 | } |

388 | }; } in |

389 | case go_Xdb lvl_scq of _ { |

390 | [] -> go_XcZ ys_Xcw; |

391 | : x_abV [Occ=Once, Dmd=Just L] xs_abW [Occ=Once, Dmd=Just L] -> |

392 | GHC.Types.: |

393 | @ GHC.Types.Int |

394 | x_abV |

395 | (GHC.Base.++ @ GHC.Types.Int xs_abW (go_XcZ ys_Xcw)) |

396 | } |

397 | }; } in |

398 | case go_XcZ lvl_sco of _ { |

399 | [] -> go_Xce sc_sfs; |

400 | : x_abV [Occ=Once, Dmd=Just L] xs_abW [Occ=Once, Dmd=Just L] -> |

401 | GHC.Types.: |

402 | @ GHC.Types.Int |

403 | x_abV |

404 | (GHC.Base.++ @ GHC.Types.Int xs_abW (go_Xce sc_sfs)) |

405 | }; |

406 | go_Xce [Occ=LoopBreaker] :: [GHC.Types.Int] -> [GHC.Types.Int] |

407 | [LclId, |

408 | Arity=1, |

409 | Str=DmdType S, |

410 | RULES: "SC:go0" [ALWAYS] |

411 | forall (sc_sfr :: GHC.Prim.Int#) (sc_sfs :: [GHC.Types.Int]). |

412 | go_Xce (GHC.Types.: @ GHC.Types.Int (GHC.Types.I# sc_sfr) sc_sfs) |

413 | = $sgo_sgj sc_sfr sc_sfs] |

414 | go_Xce = |

415 | \ (ds_Xcg [Occ=Once!] :: [GHC.Types.Int]) -> |

416 | case ds_Xcg of _ { |

417 | [] -> GHC.Types.[] @ GHC.Types.Int; |

418 | : y_Xcm [Dmd=Just D(T)] ys_Xco [Occ=Once*, Dmd=Just L] -> |

419 | letrec { |

420 | $sgo_sgo [Occ=LoopBreaker] |

421 | :: GHC.Prim.Int# -> [GHC.Types.Int] -> [GHC.Types.Int] |

422 | [LclId, Arity=2, Str=DmdType LL] |

423 | $sgo_sgo = |

424 | \ (sc_seN :: GHC.Prim.Int#) |

425 | (sc_seO [Occ=Once*] :: [GHC.Types.Int]) -> |

426 | letrec { |

427 | $sgo_sgp [Occ=LoopBreaker] |

428 | :: GHC.Prim.Int# -> [GHC.Types.Int] -> [GHC.Types.Int] |

429 | [LclId, Arity=2, Str=DmdType LL] |

430 | $sgo_sgp = |

431 | \ (sc_sfa [Occ=OnceL] :: GHC.Prim.Int#) |

432 | (sc_sfb [Occ=Once*] :: [GHC.Types.Int]) -> |

433 | letrec { |

434 | go_Xdn [Occ=LoopBreaker] :: [GHC.Types.Int] -> [GHC.Types.Int] |

435 | [LclId, Arity=1, Str=DmdType S] |

436 | go_Xdn = |

437 | \ (ds_Xdq [Occ=Once!] :: [GHC.Types.Int]) -> |

438 | case ds_Xdq of _ { |

439 | [] -> GHC.Types.[] @ GHC.Types.Int; |

440 | : y_XcC [Occ=Once!, Dmd=Just D(T)] |

441 | ys_XcE [Occ=Once*, Dmd=Just L] -> |

442 | let { |

443 | lvl_scw [Occ=OnceL, Dmd=Just D(T)] :: GHC.Types.Int |

444 | [LclId, Str=DmdType] |

445 | lvl_scw = |

446 | case y_abO |

447 | of _ { GHC.Types.I# x_abx [Occ=Once, Dmd=Just L] -> |

448 | case y_Xcm |

449 | of _ { GHC.Types.I# y_abB [Occ=Once, Dmd=Just L] -> |

450 | case y_XcC |

451 | of _ { GHC.Types.I# y_XcU [Occ=Once, Dmd=Just L] -> |

452 | GHC.Types.I# |

453 | (GHC.Prim.+# |

454 | (GHC.Prim.+# |

455 | (GHC.Prim.+# (GHC.Prim.+# x_abx y_abB) sc_seN) |

456 | sc_sfa) |

457 | y_XcU) |

458 | } |

459 | } |

460 | } } in |

461 | letrec { |

462 | go_Xcx [Occ=LoopBreaker] |

463 | :: [GHC.Types.Int] -> [GHC.Types.Int] |

464 | [LclId, Arity=1, Str=DmdType S] |

465 | go_Xcx = |

466 | \ (ds_Xcz [Occ=Once!] :: [GHC.Types.Int]) -> |

467 | case ds_Xcz of _ { |

468 | [] -> GHC.Types.[] @ GHC.Types.Int; |

469 | : y_XcF [Occ=Once, Dmd=Just D(L)] |

470 | ys_XcH [Occ=Once, Dmd=Just L] -> |

471 | GHC.Types.: |

472 | @ GHC.Types.Int |

473 | (GHC.Base.plusInt lvl_scw y_XcF) |

474 | (go_Xcx ys_XcH) |

475 | }; } in |

476 | case go_Xcx lvl_scu of _ { |

477 | [] -> go_Xdn ys_XcE; |

478 | : x_abV [Occ=Once, Dmd=Just L] |

479 | xs_abW [Occ=Once, Dmd=Just L] -> |

480 | GHC.Types.: |

481 | @ GHC.Types.Int |

482 | x_abV |

483 | (GHC.Base.++ @ GHC.Types.Int xs_abW (go_Xdn ys_XcE)) |

484 | } |

485 | }; } in |

486 | case go_Xdn lvl_scs of _ { |

487 | [] -> go_Xdb sc_sfb; |

488 | : x_abV [Occ=Once, Dmd=Just L] xs_abW [Occ=Once, Dmd=Just L] -> |

489 | GHC.Types.: |

490 | @ GHC.Types.Int |

491 | x_abV |

492 | (GHC.Base.++ @ GHC.Types.Int xs_abW (go_Xdb sc_sfb)) |

493 | }; |

494 | go_Xdb [Occ=LoopBreaker] :: [GHC.Types.Int] -> [GHC.Types.Int] |

495 | [LclId, |

496 | Arity=1, |

497 | Str=DmdType S, |

498 | RULES: "SC:go0" [ALWAYS] |

499 | forall (sc_sfa :: GHC.Prim.Int#) (sc_sfb :: [GHC.Types.Int]). |

500 | go_Xdb (GHC.Types.: |

501 | @ GHC.Types.Int (GHC.Types.I# sc_sfa) sc_sfb) |

502 | = $sgo_sgp sc_sfa sc_sfb] |

503 | go_Xdb = |

504 | \ (ds_Xcs [Occ=Once!] :: [GHC.Types.Int]) -> |

505 | case ds_Xcs of _ { |

506 | [] -> GHC.Types.[] @ GHC.Types.Int; |

507 | : y_Xcy [Dmd=Just D(T)] ys_XcA [Occ=Once*, Dmd=Just L] -> |

508 | letrec { |

509 | $sgo_sgq [Occ=LoopBreaker] |

510 | :: GHC.Prim.Int# -> [GHC.Types.Int] -> [GHC.Types.Int] |

511 | [LclId, Arity=2, Str=DmdType LL] |

512 | $sgo_sgq = |

513 | \ (sc_seZ [Occ=Once] :: GHC.Prim.Int#) |

514 | (sc_sf0 [Occ=Once*] :: [GHC.Types.Int]) -> |

515 | let { |

516 | lvl_scw [Occ=OnceL, Dmd=Just D(T)] :: GHC.Types.Int |

517 | [LclId, Str=DmdType] |

518 | lvl_scw = |

519 | case y_abO |

520 | of _ { GHC.Types.I# x_abx [Occ=Once, Dmd=Just L] -> |

521 | case y_Xcm |

522 | of _ { GHC.Types.I# y_abB [Occ=Once, Dmd=Just L] -> |

523 | case y_Xcy |

524 | of _ { GHC.Types.I# y_XcI [Occ=Once, Dmd=Just L] -> |

525 | GHC.Types.I# |

526 | (GHC.Prim.+# |

527 | (GHC.Prim.+# |

528 | (GHC.Prim.+# (GHC.Prim.+# x_abx y_abB) sc_seN) |

529 | y_XcI) |

530 | sc_seZ) |

531 | } |

532 | } |

533 | } } in |

534 | letrec { |

535 | go_Xcx [Occ=LoopBreaker] |

536 | :: [GHC.Types.Int] -> [GHC.Types.Int] |

537 | [LclId, Arity=1, Str=DmdType S] |

538 | go_Xcx = |

539 | \ (ds_Xcz [Occ=Once!] :: [GHC.Types.Int]) -> |

540 | case ds_Xcz of _ { |

541 | [] -> GHC.Types.[] @ GHC.Types.Int; |

542 | : y_XcF [Occ=Once, Dmd=Just D(L)] |

543 | ys_XcH [Occ=Once, Dmd=Just L] -> |

544 | GHC.Types.: |

545 | @ GHC.Types.Int |

546 | (GHC.Base.plusInt lvl_scw y_XcF) |

547 | (go_Xcx ys_XcH) |

548 | }; } in |

549 | case go_Xcx lvl_scu of _ { |

550 | [] -> go_Xdn sc_sf0; |

551 | : x_abV [Occ=Once, Dmd=Just L] |

552 | xs_abW [Occ=Once, Dmd=Just L] -> |

553 | GHC.Types.: |

554 | @ GHC.Types.Int |

555 | x_abV |

556 | (GHC.Base.++ @ GHC.Types.Int xs_abW (go_Xdn sc_sf0)) |

557 | }; |

558 | go_Xdn [Occ=LoopBreaker] :: [GHC.Types.Int] -> [GHC.Types.Int] |

559 | [LclId, |

560 | Arity=1, |

561 | Str=DmdType S, |

562 | RULES: "SC:go0" [ALWAYS] |

563 | forall (sc_seZ :: GHC.Prim.Int#) |

564 | (sc_sf0 :: [GHC.Types.Int]). |

565 | go_Xdn (GHC.Types.: |

566 | @ GHC.Types.Int |

567 | (GHC.Types.I# sc_seZ) |

568 | sc_sf0) |

569 | = $sgo_sgq sc_seZ sc_sf0] |

570 | go_Xdn = |

571 | \ (ds_Xdq [Occ=Once!] :: [GHC.Types.Int]) -> |

572 | case ds_Xdq of _ { |

573 | [] -> GHC.Types.[] @ GHC.Types.Int; |

574 | : y_XcC [Occ=Once!, Dmd=Just D(T)] |

575 | ys_XcE [Occ=Once*, Dmd=Just L] -> |

576 | let { |

577 | lvl_scw [Dmd=Just D(T)] :: GHC.Types.Int |

578 | [LclId, Str=DmdType] |

579 | lvl_scw = |

580 | case y_abO |

581 | of _ { GHC.Types.I# x_abx [Occ=Once, Dmd=Just L] -> |

582 | case y_Xcm |

583 | of _ { GHC.Types.I# y_abB [Occ=Once, Dmd=Just L] -> |

584 | case y_Xcy |

585 | of _ { GHC.Types.I# y_XcI [Occ=Once, Dmd=Just L] -> |

586 | case y_XcC |

587 | of _ { GHC.Types.I# y_XcU [Occ=Once, Dmd=Just L] -> |

588 | GHC.Types.I# |

589 | (GHC.Prim.+# |

590 | (GHC.Prim.+# |

591 | (GHC.Prim.+# |

592 | (GHC.Prim.+# x_abx y_abB) sc_seN) |

593 | y_XcI) |

594 | y_XcU) |

595 | } |

596 | } |

597 | } |

598 | } } in |

599 | letrec { |

600 | $sgo_sgr [Occ=LoopBreaker] |

601 | :: GHC.Types.Int |

602 | -> [GHC.Types.Int] -> [GHC.Types.Int] |

603 | [LclId, Arity=2, Str=DmdType LL] |

604 | $sgo_sgr = |

605 | \ (sc_seS [Occ=Once] :: GHC.Types.Int) |

606 | (sc_seT [Occ=Once] :: [GHC.Types.Int]) -> |

607 | GHC.Types.: |

608 | @ GHC.Types.Int |

609 | (GHC.Base.plusInt lvl_scw sc_seS) |

610 | (go_Xcx sc_seT); |

611 | go_Xcx [Occ=LoopBreaker] |

612 | :: [GHC.Types.Int] -> [GHC.Types.Int] |

613 | [LclId, |

614 | Arity=1, |

615 | Str=DmdType S, |

616 | RULES: "SC:go0" [ALWAYS] |

617 | forall (sc_seS :: GHC.Types.Int) |

618 | (sc_seT :: [GHC.Types.Int]). |

619 | go_Xcx (GHC.Types.: |

620 | @ GHC.Types.Int sc_seS sc_seT) |

621 | = $sgo_sgr sc_seS sc_seT] |

622 | go_Xcx = |

623 | \ (ds_Xcz [Occ=Once!] :: [GHC.Types.Int]) -> |

624 | case ds_Xcz of _ { |

625 | [] -> GHC.Types.[] @ GHC.Types.Int; |

626 | : y_XcF [Occ=Once, Dmd=Just D(L)] |

627 | ys_XcH [Occ=Once, Dmd=Just L] -> |

628 | GHC.Types.: |

629 | @ GHC.Types.Int |

630 | (GHC.Base.plusInt lvl_scw y_XcF) |

631 | (go_Xcx ys_XcH) |

632 | }; } in |

633 | case go_Xcx lvl_scu of _ { |

634 | [] -> go_Xdn ys_XcE; |

635 | : x_abV [Occ=Once, Dmd=Just L] |

636 | xs_abW [Occ=Once, Dmd=Just L] -> |

637 | GHC.Types.: |

638 | @ GHC.Types.Int |

639 | x_abV |

640 | (GHC.Base.++ |

641 | @ GHC.Types.Int xs_abW (go_Xdn ys_XcE)) |

642 | } |

643 | }; } in |

644 | case go_Xdn lvl_scs of _ { |

645 | [] -> go_Xdb ys_XcA; |

646 | : x_abV [Occ=Once, Dmd=Just L] xs_abW [Occ=Once, Dmd=Just L] -> |

647 | GHC.Types.: |

648 | @ GHC.Types.Int |

649 | x_abV |

650 | (GHC.Base.++ @ GHC.Types.Int xs_abW (go_Xdb ys_XcA)) |

651 | } |

652 | }; } in |

653 | case go_Xdb lvl_scq of _ { |

654 | [] -> go_XcZ sc_seO; |

655 | : x_abV [Occ=Once, Dmd=Just L] xs_abW [Occ=Once, Dmd=Just L] -> |

656 | GHC.Types.: |

657 | @ GHC.Types.Int |

658 | x_abV |

659 | (GHC.Base.++ @ GHC.Types.Int xs_abW (go_XcZ sc_seO)) |

660 | }; |

661 | go_XcZ [Occ=LoopBreaker] :: [GHC.Types.Int] -> [GHC.Types.Int] |

662 | [LclId, |

663 | Arity=1, |

664 | Str=DmdType S, |

665 | RULES: "SC:go0" [ALWAYS] |

666 | forall (sc_seN :: GHC.Prim.Int#) (sc_seO :: [GHC.Types.Int]). |

667 | go_XcZ (GHC.Types.: @ GHC.Types.Int (GHC.Types.I# sc_seN) sc_seO) |

668 | = $sgo_sgo sc_seN sc_seO] |

669 | go_XcZ = |

670 | \ (ds_Xd2 [Occ=Once!] :: [GHC.Types.Int]) -> |

671 | case ds_Xd2 of _ { |

672 | [] -> GHC.Types.[] @ GHC.Types.Int; |

673 | : y_Xcu [Dmd=Just D(T)] ys_Xcw [Occ=Once*, Dmd=Just L] -> |

674 | letrec { |

675 | $sgo_sgs [Occ=LoopBreaker] |

676 | :: GHC.Prim.Int# -> [GHC.Types.Int] -> [GHC.Types.Int] |

677 | [LclId, Arity=2, Str=DmdType LL] |

678 | $sgo_sgs = |

679 | \ (sc_sem :: GHC.Prim.Int#) |

680 | (sc_sen [Occ=Once*] :: [GHC.Types.Int]) -> |

681 | letrec { |

682 | $sgo_sgt [Occ=LoopBreaker] |

683 | :: GHC.Prim.Int# -> [GHC.Types.Int] -> [GHC.Types.Int] |

684 | [LclId, Arity=2, Str=DmdType LL] |

685 | $sgo_sgt = |

686 | \ (sc_sey [Occ=Once] :: GHC.Prim.Int#) |

687 | (sc_sez [Occ=Once*] :: [GHC.Types.Int]) -> |

688 | let { |

689 | lvl_scw [Occ=OnceL, Dmd=Just D(T)] :: GHC.Types.Int |

690 | [LclId, Str=DmdType] |

691 | lvl_scw = |

692 | case y_abO |

693 | of _ { GHC.Types.I# x_abx [Occ=Once, Dmd=Just L] -> |

694 | case y_Xcm |

695 | of _ { GHC.Types.I# y_abB [Occ=Once, Dmd=Just L] -> |

696 | case y_Xcu |

697 | of _ { GHC.Types.I# y_Xdr [Occ=Once, Dmd=Just L] -> |

698 | GHC.Types.I# |

699 | (GHC.Prim.+# |

700 | (GHC.Prim.+# |

701 | (GHC.Prim.+# (GHC.Prim.+# x_abx y_abB) y_Xdr) |

702 | sc_sem) |

703 | sc_sey) |

704 | } |

705 | } |

706 | } } in |

707 | letrec { |

708 | go_Xcx [Occ=LoopBreaker] |

709 | :: [GHC.Types.Int] -> [GHC.Types.Int] |

710 | [LclId, Arity=1, Str=DmdType S] |

711 | go_Xcx = |

712 | \ (ds_Xcz [Occ=Once!] :: [GHC.Types.Int]) -> |

713 | case ds_Xcz of _ { |

714 | [] -> GHC.Types.[] @ GHC.Types.Int; |

715 | : y_XcF [Occ=Once, Dmd=Just D(L)] |

716 | ys_XcH [Occ=Once, Dmd=Just L] -> |

717 | GHC.Types.: |

718 | @ GHC.Types.Int |

719 | (GHC.Base.plusInt lvl_scw y_XcF) |

720 | (go_Xcx ys_XcH) |

721 | }; } in |

722 | case go_Xcx lvl_scu of _ { |

723 | [] -> go_Xdn sc_sez; |

724 | : x_abV [Occ=Once, Dmd=Just L] |

725 | xs_abW [Occ=Once, Dmd=Just L] -> |

726 | GHC.Types.: |

727 | @ GHC.Types.Int |

728 | x_abV |

729 | (GHC.Base.++ @ GHC.Types.Int xs_abW (go_Xdn sc_sez)) |

730 | }; |

731 | go_Xdn [Occ=LoopBreaker] :: [GHC.Types.Int] -> [GHC.Types.Int] |

732 | [LclId, |

733 | Arity=1, |

734 | Str=DmdType S, |

735 | RULES: "SC:go0" [ALWAYS] |

736 | forall (sc_sey :: GHC.Prim.Int#) |

737 | (sc_sez :: [GHC.Types.Int]). |

738 | go_Xdn (GHC.Types.: |

739 | @ GHC.Types.Int |

740 | (GHC.Types.I# sc_sey) |

741 | sc_sez) |

742 | = $sgo_sgt sc_sey sc_sez] |

743 | go_Xdn = |

744 | \ (ds_Xdq [Occ=Once!] :: [GHC.Types.Int]) -> |

745 | case ds_Xdq of _ { |

746 | [] -> GHC.Types.[] @ GHC.Types.Int; |

747 | : y_XcC [Occ=Once!, Dmd=Just D(T)] |

748 | ys_XcE [Occ=Once*, Dmd=Just L] -> |

749 | let { |

750 | lvl_scw [Dmd=Just D(T)] :: GHC.Types.Int |

751 | [LclId, Str=DmdType] |

752 | lvl_scw = |

753 | case y_abO |

754 | of _ { GHC.Types.I# x_abx [Occ=Once, Dmd=Just L] -> |

755 | case y_Xcm |

756 | of _ { GHC.Types.I# y_abB [Occ=Once, Dmd=Just L] -> |

757 | case y_Xcu |

758 | of _ { GHC.Types.I# y_Xdr [Occ=Once, Dmd=Just L] -> |

759 | case y_XcC |

760 | of _ { GHC.Types.I# y_XcU [Occ=Once, Dmd=Just L] -> |

761 | GHC.Types.I# |

762 | (GHC.Prim.+# |

763 | (GHC.Prim.+# |

764 | (GHC.Prim.+# |

765 | (GHC.Prim.+# x_abx y_abB) y_Xdr) |

766 | sc_sem) |

767 | y_XcU) |

768 | } |

769 | } |

770 | } |

771 | } } in |

772 | letrec { |

773 | $sgo_sgu [Occ=LoopBreaker] |

774 | :: GHC.Types.Int |

775 | -> [GHC.Types.Int] -> [GHC.Types.Int] |

776 | [LclId, Arity=2, Str=DmdType LL] |

777 | $sgo_sgu = |

778 | \ (sc_ser [Occ=Once] :: GHC.Types.Int) |

779 | (sc_ses [Occ=Once] :: [GHC.Types.Int]) -> |

780 | GHC.Types.: |

781 | @ GHC.Types.Int |

782 | (GHC.Base.plusInt lvl_scw sc_ser) |

783 | (go_Xcx sc_ses); |

784 | go_Xcx [Occ=LoopBreaker] |

785 | :: [GHC.Types.Int] -> [GHC.Types.Int] |

786 | [LclId, |

787 | Arity=1, |

788 | Str=DmdType S, |

789 | RULES: "SC:go0" [ALWAYS] |

790 | forall (sc_ser :: GHC.Types.Int) |

791 | (sc_ses :: [GHC.Types.Int]). |

792 | go_Xcx (GHC.Types.: |

793 | @ GHC.Types.Int sc_ser sc_ses) |

794 | = $sgo_sgu sc_ser sc_ses] |

795 | go_Xcx = |

796 | \ (ds_Xcz [Occ=Once!] :: [GHC.Types.Int]) -> |

797 | case ds_Xcz of _ { |

798 | [] -> GHC.Types.[] @ GHC.Types.Int; |

799 | : y_XcF [Occ=Once, Dmd=Just D(L)] |

800 | ys_XcH [Occ=Once, Dmd=Just L] -> |

801 | GHC.Types.: |

802 | @ GHC.Types.Int |

803 | (GHC.Base.plusInt lvl_scw y_XcF) |

804 | (go_Xcx ys_XcH) |

805 | }; } in |

806 | case go_Xcx lvl_scu of _ { |

807 | [] -> go_Xdn ys_XcE; |

808 | : x_abV [Occ=Once, Dmd=Just L] |

809 | xs_abW [Occ=Once, Dmd=Just L] -> |

810 | GHC.Types.: |

811 | @ GHC.Types.Int |

812 | x_abV |

813 | (GHC.Base.++ |

814 | @ GHC.Types.Int xs_abW (go_Xdn ys_XcE)) |

815 | } |

816 | }; } in |

817 | case go_Xdn lvl_scs of _ { |

818 | [] -> go_Xdb sc_sen; |

819 | : x_abV [Occ=Once, Dmd=Just L] xs_abW [Occ=Once, Dmd=Just L] -> |

820 | GHC.Types.: |

821 | @ GHC.Types.Int |

822 | x_abV |

823 | (GHC.Base.++ @ GHC.Types.Int xs_abW (go_Xdb sc_sen)) |

824 | }; |

825 | go_Xdb [Occ=LoopBreaker] :: [GHC.Types.Int] -> [GHC.Types.Int] |

826 | [LclId, |

827 | Arity=1, |

828 | Str=DmdType S, |

829 | RULES: "SC:go0" [ALWAYS] |

830 | forall (sc_sem :: GHC.Prim.Int#) |

831 | (sc_sen :: [GHC.Types.Int]). |

832 | go_Xdb (GHC.Types.: |

833 | @ GHC.Types.Int (GHC.Types.I# sc_sem) sc_sen) |

834 | = $sgo_sgs sc_sem sc_sen] |

835 | go_Xdb = |

836 | \ (ds_Xcs [Occ=Once!] :: [GHC.Types.Int]) -> |

837 | case ds_Xcs of _ { |

838 | [] -> GHC.Types.[] @ GHC.Types.Int; |

839 | : y_Xcy [Dmd=Just D(T)] ys_XcA [Occ=Once*, Dmd=Just L] -> |

840 | letrec { |

841 | $sgo_sgv [Occ=LoopBreaker] |

842 | :: GHC.Prim.Int# -> [GHC.Types.Int] -> [GHC.Types.Int] |

843 | [LclId, Arity=2, Str=DmdType LL] |

844 | $sgo_sgv = |

845 | \ (sc_se6 [Occ=Once] :: GHC.Prim.Int#) |

846 | (sc_se7 [Occ=Once*] :: [GHC.Types.Int]) -> |

847 | let { |

848 | lvl_scw [Dmd=Just D(T)] :: GHC.Types.Int |

849 | [LclId, Str=DmdType] |

850 | lvl_scw = |

851 | case y_abO |

852 | of _ { GHC.Types.I# x_abx [Occ=Once, Dmd=Just L] -> |

853 | case y_Xcm |

854 | of _ { GHC.Types.I# y_abB [Occ=Once, Dmd=Just L] -> |

855 | case y_Xcu |

856 | of _ { GHC.Types.I# y_Xdr [Occ=Once, Dmd=Just L] -> |

857 | case y_Xcy |

858 | of _ { GHC.Types.I# y_XcI [Occ=Once, Dmd=Just L] -> |

859 | GHC.Types.I# |

860 | (GHC.Prim.+# |

861 | (GHC.Prim.+# |

862 | (GHC.Prim.+# |

863 | (GHC.Prim.+# x_abx y_abB) y_Xdr) |

864 | y_XcI) |

865 | sc_se6) |

866 | } |

867 | } |

868 | } |

869 | } } in |

870 | letrec { |

871 | $sgo_sgw [Occ=LoopBreaker] |

872 | :: GHC.Types.Int |

873 | -> [GHC.Types.Int] -> [GHC.Types.Int] |

874 | [LclId, Arity=2, Str=DmdType LL] |

875 | $sgo_sgw = |

876 | \ (sc_seb [Occ=Once] :: GHC.Types.Int) |

877 | (sc_sec [Occ=Once] :: [GHC.Types.Int]) -> |

878 | GHC.Types.: |

879 | @ GHC.Types.Int |

880 | (GHC.Base.plusInt lvl_scw sc_seb) |

881 | (go_Xcx sc_sec); |

882 | go_Xcx [Occ=LoopBreaker] |

883 | :: [GHC.Types.Int] -> [GHC.Types.Int] |

884 | [LclId, |

885 | Arity=1, |

886 | Str=DmdType S, |

887 | RULES: "SC:go0" [ALWAYS] |

888 | forall (sc_seb :: GHC.Types.Int) |

889 | (sc_sec :: [GHC.Types.Int]). |

890 | go_Xcx (GHC.Types.: |

891 | @ GHC.Types.Int sc_seb sc_sec) |

892 | = $sgo_sgw sc_seb sc_sec] |

893 | go_Xcx = |

894 | \ (ds_Xcz [Occ=Once!] :: [GHC.Types.Int]) -> |

895 | case ds_Xcz of _ { |

896 | [] -> GHC.Types.[] @ GHC.Types.Int; |

897 | : y_XcF [Occ=Once, Dmd=Just D(L)] |

898 | ys_XcH [Occ=Once, Dmd=Just L] -> |

899 | GHC.Types.: |

900 | @ GHC.Types.Int |

901 | (GHC.Base.plusInt lvl_scw y_XcF) |

902 | (go_Xcx ys_XcH) |

903 | }; } in |

904 | case go_Xcx lvl_scu of _ { |

905 | [] -> go_Xdn sc_se7; |

906 | : x_abV [Occ=Once, Dmd=Just L] |

907 | xs_abW [Occ=Once, Dmd=Just L] -> |

908 | GHC.Types.: |

909 | @ GHC.Types.Int |

910 | x_abV |

911 | (GHC.Base.++ |

912 | @ GHC.Types.Int xs_abW (go_Xdn sc_se7)) |

913 | }; |

914 | go_Xdn [Occ=LoopBreaker] |

915 | :: [GHC.Types.Int] -> [GHC.Types.Int] |

916 | [LclId, |

917 | Arity=1, |

918 | Str=DmdType S, |

919 | RULES: "SC:go0" [ALWAYS] |

920 | forall (sc_se6 :: GHC.Prim.Int#) |

921 | (sc_se7 :: [GHC.Types.Int]). |

922 | go_Xdn (GHC.Types.: |

923 | @ GHC.Types.Int |

924 | (GHC.Types.I# sc_se6) |

925 | sc_se7) |

926 | = $sgo_sgv sc_se6 sc_se7] |

927 | go_Xdn = |

928 | \ (ds_Xdq [Occ=Once!] :: [GHC.Types.Int]) -> |

929 | case ds_Xdq of _ { |

930 | [] -> GHC.Types.[] @ GHC.Types.Int; |

931 | : y_XcC [Occ=Once!, Dmd=Just D(T)] |

932 | ys_XcE [Occ=Once*, Dmd=Just L] -> |

933 | let { |

934 | lvl_scw [Dmd=Just D(T)] :: GHC.Types.Int |

935 | [LclId, Str=DmdType] |

936 | lvl_scw = |

937 | case y_abO |

938 | of _ |

939 | { GHC.Types.I# x_abx [Occ=Once, Dmd=Just L] -> |

940 | case y_Xcm |

941 | of _ |

942 | { GHC.Types.I# y_abB [Occ=Once, Dmd=Just L] -> |

943 | case y_Xcu |

944 | of _ |

945 | { GHC.Types.I# y_Xdr [Occ=Once, Dmd=Just L] -> |

946 | case y_Xcy |

947 | of _ |

948 | { GHC.Types.I# y_XcI [Occ=Once, Dmd=Just L] -> |

949 | case y_XcC |

950 | of _ |

951 | { GHC.Types.I# y_XcU [Occ=Once, Dmd=Just L] -> |

952 | GHC.Types.I# |

953 | (GHC.Prim.+# |

954 | (GHC.Prim.+# |

955 | (GHC.Prim.+# |

956 | (GHC.Prim.+# x_abx y_abB) y_Xdr) |

957 | y_XcI) |

958 | y_XcU) |

959 | } |

960 | } |

961 | } |

962 | } |

963 | } } in |

964 | letrec { |

965 | $sgo_sgx [Occ=LoopBreaker] |

966 | :: GHC.Types.Int |

967 | -> [GHC.Types.Int] -> [GHC.Types.Int] |

968 | [LclId, Arity=2, Str=DmdType LL] |

969 | $sgo_sgx = |

970 | \ (sc_sdZ [Occ=Once] :: GHC.Types.Int) |

971 | (sc_se0 [Occ=Once] :: [GHC.Types.Int]) -> |

972 | GHC.Types.: |

973 | @ GHC.Types.Int |

974 | (GHC.Base.plusInt lvl_scw sc_sdZ) |

975 | (go_Xcx sc_se0); |

976 | go_Xcx [Occ=LoopBreaker] |

977 | :: [GHC.Types.Int] -> [GHC.Types.Int] |

978 | [LclId, |

979 | Arity=1, |

980 | Str=DmdType S, |

981 | RULES: "SC:go0" [ALWAYS] |

982 | forall (sc_sdZ :: GHC.Types.Int) |

983 | (sc_se0 :: [GHC.Types.Int]). |

984 | go_Xcx (GHC.Types.: |

985 | @ GHC.Types.Int |

986 | sc_sdZ |

987 | sc_se0) |

988 | = $sgo_sgx sc_sdZ sc_se0] |

989 | go_Xcx = |

990 | \ (ds_Xcz [Occ=Once!] :: [GHC.Types.Int]) -> |

991 | case ds_Xcz of _ { |

992 | [] -> GHC.Types.[] @ GHC.Types.Int; |

993 | : y_XcF [Occ=Once, Dmd=Just D(L)] |

994 | ys_XcH [Occ=Once, Dmd=Just L] -> |

995 | GHC.Types.: |

996 | @ GHC.Types.Int |

997 | (GHC.Base.plusInt lvl_scw y_XcF) |

998 | (go_Xcx ys_XcH) |

999 | }; } in |

1000 | case go_Xcx lvl_scu of _ { |

1001 | [] -> go_Xdn ys_XcE; |

1002 | : x_abV [Occ=Once, Dmd=Just L] |

1003 | xs_abW [Occ=Once, Dmd=Just L] -> |

1004 | GHC.Types.: |

1005 | @ GHC.Types.Int |

1006 | x_abV |

1007 | (GHC.Base.++ |

1008 | @ GHC.Types.Int xs_abW (go_Xdn ys_XcE)) |

1009 | } |

1010 | }; } in |

1011 | case go_Xdn lvl_scs of _ { |

1012 | [] -> go_Xdb ys_XcA; |

1013 | : x_abV [Occ=Once, Dmd=Just L] |

1014 | xs_abW [Occ=Once, Dmd=Just L] -> |

1015 | GHC.Types.: |

1016 | @ GHC.Types.Int |

1017 | x_abV |

1018 | (GHC.Base.++ @ GHC.Types.Int xs_abW (go_Xdb ys_XcA)) |

1019 | } |

1020 | }; } in |

1021 | case go_Xdb lvl_scq of _ { |

1022 | [] -> go_XcZ ys_Xcw; |

1023 | : x_abV [Occ=Once, Dmd=Just L] xs_abW [Occ=Once, Dmd=Just L] -> |

1024 | GHC.Types.: |

1025 | @ GHC.Types.Int |

1026 | x_abV |

1027 | (GHC.Base.++ @ GHC.Types.Int xs_abW (go_XcZ ys_Xcw)) |

1028 | } |

1029 | }; } in |

1030 | case go_XcZ lvl_sco of _ { |

1031 | [] -> go_Xce ys_Xco; |

1032 | : x_abV [Occ=Once, Dmd=Just L] xs_abW [Occ=Once, Dmd=Just L] -> |

1033 | GHC.Types.: |

1034 | @ GHC.Types.Int |

1035 | x_abV |

1036 | (GHC.Base.++ @ GHC.Types.Int xs_abW (go_Xce ys_Xco)) |

1037 | } |

1038 | }; } in |

1039 | case go_Xce lvl_scm of _ { |

1040 | [] -> go_abJ ys_abP; |

1041 | : x_abV [Occ=Once, Dmd=Just L] xs_abW [Occ=Once, Dmd=Just L] -> |

1042 | GHC.Types.: |

1043 | @ GHC.Types.Int |

1044 | x_abV |

1045 | (GHC.Base.++ @ GHC.Types.Int xs_abW (go_abJ ys_abP)) |

1046 | } |

1047 | } |

1048 | end Rec } |

1049 | |

1050 | lvl_sdS [Occ=Once] :: GHC.Types.Int |

1051 | [LclId] |

1052 | lvl_sdS = GHC.Types.I# 0 |

1053 | |

1054 | lvl_sdR [Occ=Once] :: [GHC.Types.Int] |

1055 | [LclId] |

1056 | lvl_sdR = |

1057 | GHC.Types.: @ GHC.Types.Int lvl_sdS (GHC.Types.[] @ GHC.Types.Int) |

1058 | |

1059 | Foo.output :: [GHC.Types.Int] |

1060 | [LclIdX, Str=DmdType] |

1061 | Foo.output = go_abJ lvl_sdR |

1062 |