summaryrefslogtreecommitdiff
path: root/.stack-work/dist/x86_64-linux/Cabal-2.4.0.1/build/8queens/8queens-tmp/src/Main.dump-hi
diff options
context:
space:
mode:
Diffstat (limited to '.stack-work/dist/x86_64-linux/Cabal-2.4.0.1/build/8queens/8queens-tmp/src/Main.dump-hi')
-rw-r--r--.stack-work/dist/x86_64-linux/Cabal-2.4.0.1/build/8queens/8queens-tmp/src/Main.dump-hi2517
1 files changed, 0 insertions, 2517 deletions
diff --git a/.stack-work/dist/x86_64-linux/Cabal-2.4.0.1/build/8queens/8queens-tmp/src/Main.dump-hi b/.stack-work/dist/x86_64-linux/Cabal-2.4.0.1/build/8queens/8queens-tmp/src/Main.dump-hi
deleted file mode 100644
index f380580..0000000
--- a/.stack-work/dist/x86_64-linux/Cabal-2.4.0.1/build/8queens/8queens-tmp/src/Main.dump-hi
+++ /dev/null
@@ -1,2517 +0,0 @@
1
2==================== FINAL INTERFACE ====================
32019-05-29 23:57:35.287700482 UTC
4
5interface main:Main 8065
6 interface hash: 47c5f1b0ac88d7964b8d3ff4b4c5ad24
7 ABI hash: 6a25402bbb47d2db70b5fccc80b8cd10
8 export-list hash: 14799b7f7205366154cf4737867653f6
9 orphan hash: 544728fd6478f60c87fd98f72c918bf5
10 flag hash: 1638722aa932cf70c70adfffb210f5e7
11 opt_hash: 6faf2de08de32d19db9870899d88e59a
12 hpc_hash: 93b885adfe0da089cdf634904fd59f71
13 plugin_hash: ad164012d6b1e14942349d58b1132007
14 sig of: Nothing
15 used TH splices: False
16 where
17exports:
18 Main.allPositions
19 Main.allops
20 Main.applyop
21 Main.applyops
22 Main.diag
23 Main.diag''
24 Main.getColL
25 Main.getDiagL
26 Main.getRowColDiag
27 Main.getRowL
28 Main.initBoard
29 Main.isWinnable
30 Main.isWinnable'
31 Main.lo8
32 Main.main
33 Main.mapDiag
34 Main.mapQueensPath
35 Main.mapRowColDiag
36 Main.markX
37 Main.nextAvail
38 Main.nextOpen
39 Main.onBoard
40 Main.openPositions
41 Main.ops
42 Main.placeQueen
43 Main.placeQueen'
44 Main.queenAllowed
45 Main.s
46 Main.scanBoard
47 Main.solve
48 Main.w
49 Main.winnable
50 Main.winners
51 Main.winners'
52 Main.Square{Main.O Main.Qu Main.T Main.X}
53module dependencies:
54package dependencies: StateVar-1.1.1.1 adjunctions-4.4
55 array-0.5.3.0 base-4.12.0.0 base-orphans-0.8.1 bifunctors-5.5.4
56 binary-0.8.6.0 bytes-0.15.5 bytestring-0.10.8.2 call-stack-0.1.0
57 cereal-0.5.8.0 comonad-5.0.5 containers-0.6.0.1 contravariant-1.5.1
58 deepseq-1.4.4.0 distributive-0.6 exceptions-0.10.2 free-5.1.1
59 ghc-boot-th-8.6.5 ghc-prim-0.5.3 hashable-1.2.7.0
60 integer-gmp-1.0.2.0 integer-logarithms-1.0.3 kan-extensions-5.2
61 lens-4.17.1 linear-1.20.9 loop-0.3.0 matrix-0.3.6.1 mtl-2.2.2
62 pretty-1.1.3.6 primitive-0.6.4.0 profunctors-5.3 random-1.1
63 reflection-2.1.4 scientific-0.3.6.2 semigroupoids-5.3.2 stm-2.5.0.0
64 tagged-0.8.6 template-haskell-2.14.0.0 text-1.2.3.1
65 th-abstraction-0.2.11.0 time-1.8.0.2 transformers-0.5.6.2
66 transformers-base-0.4.5.2 transformers-compat-0.6.5
67 unordered-containers-0.2.9.0 vector-0.12.0.3
68orphans: time-1.8.0.2:Data.Time.Clock.TAI
69 reflection-2.1.4:Data.Reflection
70 vector-0.12.0.3:Data.Vector.Unboxed stm-2.5.0.0:Control.Monad.STM
71 hashable-1.2.7.0:Data.Hashable.Generic text-1.2.3.1:Data.Text.Lazy
72 text-1.2.3.1:Data.Text binary-0.8.6.0:Data.Binary.Generic
73 bytestring-0.10.8.2:Data.ByteString.Builder
74 text-1.2.3.1:Data.Text.Show linear-1.20.9:Linear.Instances
75 vector-0.12.0.3:Data.Vector.Fusion.Bundle
76 transformers-0.5.6.2:Control.Monad.Trans.Error
77 time-1.8.0.2:Data.Time.Format.Parse
78 time-1.8.0.2:Data.Time.LocalTime.Internal.ZonedTime
79 time-1.8.0.2:Data.Time.LocalTime.Internal.LocalTime
80 time-1.8.0.2:Data.Time.Calendar.Gregorian base-4.12.0.0:GHC.Float
81 base-4.12.0.0:GHC.Base
82family instance modules: adjunctions-4.4:Data.Functor.Rep
83 base-4.12.0.0:Control.Applicative base-4.12.0.0:Data.Complex
84 base-4.12.0.0:Data.Functor.Compose base-4.12.0.0:Data.Functor.Const
85 base-4.12.0.0:Data.Functor.Identity
86 base-4.12.0.0:Data.Functor.Product base-4.12.0.0:Data.Functor.Sum
87 base-4.12.0.0:Data.Monoid base-4.12.0.0:Data.Semigroup
88 base-4.12.0.0:Data.Semigroup.Internal base-4.12.0.0:Data.Version
89 base-4.12.0.0:Data.Void base-4.12.0.0:GHC.Exts
90 base-4.12.0.0:GHC.Generics base-4.12.0.0:GHC.IO.Exception
91 bifunctors-5.5.4:Data.Bifunctor.Biff
92 bifunctors-5.5.4:Data.Bifunctor.Clown
93 bifunctors-5.5.4:Data.Bifunctor.Fix
94 bifunctors-5.5.4:Data.Bifunctor.Flip
95 bifunctors-5.5.4:Data.Bifunctor.Join
96 bifunctors-5.5.4:Data.Bifunctor.Joker
97 bifunctors-5.5.4:Data.Bifunctor.Product
98 bifunctors-5.5.4:Data.Bifunctor.Sum
99 bifunctors-5.5.4:Data.Bifunctor.Tannen
100 bifunctors-5.5.4:Data.Bifunctor.Wrapped bytes-0.15.5:Data.Bytes.Get
101 bytes-0.15.5:Data.Bytes.Signed bytes-0.15.5:Data.Bytes.VarInt
102 containers-0.6.0.1:Data.IntMap.Internal
103 containers-0.6.0.1:Data.IntSet.Internal
104 containers-0.6.0.1:Data.Map.Internal
105 containers-0.6.0.1:Data.Sequence.Internal
106 containers-0.6.0.1:Data.Set.Internal containers-0.6.0.1:Data.Tree
107 free-5.1.1:Control.Comonad.Cofree
108 free-5.1.1:Control.Comonad.Trans.Cofree
109 free-5.1.1:Control.Monad.Free free-5.1.1:Control.Monad.Trans.Free
110 ghc-boot-th-8.6.5:GHC.ForeignSrcLang.Type
111 ghc-boot-th-8.6.5:GHC.LanguageExtensions.Type
112 kan-extensions-5.2:Data.Functor.Day
113 kan-extensions-5.2:Data.Functor.Yoneda lens-4.17.1:Control.Lens.At
114 lens-4.17.1:Control.Lens.Internal.Indexed
115 lens-4.17.1:Control.Lens.Reified lens-4.17.1:Control.Lens.Tuple
116 lens-4.17.1:Control.Lens.Wrapped lens-4.17.1:Control.Lens.Zoom
117 linear-1.20.9:Linear.V linear-1.20.9:Linear.V1
118 linear-1.20.9:Linear.V2 linear-1.20.9:Linear.V3
119 matrix-0.3.6.1:Data.Matrix
120 pretty-1.1.3.6:Text.PrettyPrint.Annotated.HughesPJ
121 pretty-1.1.3.6:Text.PrettyPrint.HughesPJ
122 primitive-0.6.4.0:Control.Monad.Primitive
123 primitive-0.6.4.0:Data.Primitive.Array
124 primitive-0.6.4.0:Data.Primitive.ByteArray
125 primitive-0.6.4.0:Data.Primitive.PrimArray
126 primitive-0.6.4.0:Data.Primitive.SmallArray
127 primitive-0.6.4.0:Data.Primitive.UnliftedArray
128 profunctors-5.3:Data.Profunctor.Composition
129 profunctors-5.3:Data.Profunctor.Rep tagged-0.8.6:Data.Tagged
130 template-haskell-2.14.0.0:Language.Haskell.TH.Syntax
131 text-1.2.3.1:Data.Text text-1.2.3.1:Data.Text.Lazy
132 th-abstraction-0.2.11.0:Language.Haskell.TH.Datatype
133 unordered-containers-0.2.9.0:Data.HashMap.Base
134 unordered-containers-0.2.9.0:Data.HashSet
135 vector-0.12.0.3:Data.Vector vector-0.12.0.3:Data.Vector.Primitive
136 vector-0.12.0.3:Data.Vector.Storable
137 vector-0.12.0.3:Data.Vector.Unboxed
138 vector-0.12.0.3:Data.Vector.Unboxed.Base
139import -/ base-4.12.0.0:Control.Applicative 2ae514eb141d45774730765c61bb41c0
140import -/ base-4.12.0.0:Data.Foldable efb37371da929e7bc88d896298d2d979
141import -/ base-4.12.0.0:Data.List 17d0c71c557e42abe196f130788fd997
142import -/ base-4.12.0.0:Data.OldList e931cf456dc87f11ee6e6fb153bca23e
143import -/ base-4.12.0.0:Data.Tuple c719fc29608fe81c10bee9a1bf1e05ff
144import -/ base-4.12.0.0:Foreign.Storable 379843bb6beffe814f03155babd3a2a1
145import -/ base-4.12.0.0:GHC.Base c00b75f0b052d05c55ba6a4dd1c63b26
146import -/ base-4.12.0.0:GHC.Err ea5e313ef4146b40b5d8b27aa168e736
147import -/ base-4.12.0.0:GHC.List 4014a3c8a3b7c31c8325f6bcf1feea4a
148import -/ base-4.12.0.0:GHC.Num c2039f03637c68f47b0bbff4c18ec616
149import -/ base-4.12.0.0:GHC.Show 838a5d039379d82d9626aae53dfce276
150import -/ base-4.12.0.0:Prelude 3c779dfd6448bdd8e234c336802c2acb
151import -/ base-4.12.0.0:System.IO dd4f3cfe73b94b7cae46a4ca98a3f09f
152import -/ ghc-prim-0.5.3:GHC.Classes 0f6fd7d7db53fc48f6e1f01803cc6c9d
153import -/ ghc-prim-0.5.3:GHC.Types 57064c9f957b09bc2e360061ad5cae0b
154import -/ lens-4.17.1:Control.Lens 3653945a21240fa9b051785ff6456731
155import -/ linear-1.20.9:Linear.V2 d56aa147d201434486a0d7613b12118c
156import -/ linear-1.20.9:Linear.V3 1dcebeca95d66b9152a160ce7257a571
157import -/ matrix-0.3.6.1:Data.Matrix 352cbb223ecd1589261f36f7ff17bc9c
158import -/ random-1.1:System.Random c6898761a03910f08acbe56f79c5fa96
159import -/ vector-0.12.0.3:Data.Vector 2f7b7a0ec8b90d2d82b017d1a022e0b2
160636ccc849665ce7c3156c440898486e4
161 $fEqSquare :: GHC.Classes.Eq Main.Square
162 DFunId
163 {- HasNoCafRefs, Strictness: m, Inline: CONLIKE,
164 Unfolding: DFun:.
165 @ Main.Square Main.$fEqSquare_$c== Main.$fEqSquare_$c/= -}
166636ccc849665ce7c3156c440898486e4
167 $fEqSquare_$c/= :: Main.Square -> Main.Square -> GHC.Types.Bool
168 {- Arity: 2, HasNoCafRefs, Strictness: <S,1*U><S,1*U>,
169 Inline: (sat-args=2),
170 Unfolding: InlineRule (2, False, False)
171 (\ (x :: Main.Square) (y :: Main.Square) ->
172 case x of wild {
173 Main.X
174 -> case y of wild1 {
175 DEFAULT -> GHC.Types.True Main.X -> GHC.Types.False }
176 Main.Qu
177 -> case y of wild1 {
178 DEFAULT -> GHC.Types.True Main.Qu -> GHC.Types.False }
179 Main.O
180 -> case y of wild1 {
181 DEFAULT -> GHC.Types.True Main.O -> GHC.Types.False }
182 Main.T
183 -> case y of wild1 {
184 DEFAULT -> GHC.Types.True Main.T -> GHC.Types.False } }) -}
185636ccc849665ce7c3156c440898486e4
186 $fEqSquare_$c== :: Main.Square -> Main.Square -> GHC.Types.Bool
187 {- Arity: 2, HasNoCafRefs, Strictness: <S,1*U><S,1*U>,
188 Unfolding: (\ (ds :: Main.Square) (ds1 :: Main.Square) ->
189 case ds of wild {
190 Main.X
191 -> case ds1 of wild1 {
192 DEFAULT -> GHC.Types.False Main.X -> GHC.Types.True }
193 Main.Qu
194 -> case ds1 of wild1 {
195 DEFAULT -> GHC.Types.False Main.Qu -> GHC.Types.True }
196 Main.O
197 -> case ds1 of wild1 {
198 DEFAULT -> GHC.Types.False Main.O -> GHC.Types.True }
199 Main.T
200 -> case ds1 of wild1 {
201 DEFAULT -> GHC.Types.False Main.T -> GHC.Types.True } }) -}
202636ccc849665ce7c3156c440898486e4
203 $fShowSquare :: GHC.Show.Show Main.Square
204 DFunId
205 {- Strictness: m, Inline: CONLIKE,
206 Unfolding: DFun:.
207 @ Main.Square
208 Main.$fShowSquare_$cshowsPrec
209 Main.$fShowSquare_$cshow
210 Main.$fShowSquare_$cshowList -}
2114034c5a8da4227c6e128ffb263a94e31
212 $fShowSquare1 :: [GHC.Types.Char]
213 {- Unfolding: (GHC.CString.unpackCString# Main.$fShowSquare2) -}
21483314de2c755664d070f9c06df865e32
215 $fShowSquare2 :: GHC.Prim.Addr#
216 {- HasNoCafRefs, Unfolding: ("T"#) -}
21749ff713629ce3b98fedf0d710cd5834f
218 $fShowSquare3 :: [GHC.Types.Char]
219 {- Unfolding: (GHC.CString.unpackCString# Main.$fShowSquare4) -}
22015c027c2ef0f750ada425ea516d40011
221 $fShowSquare4 :: GHC.Prim.Addr#
222 {- HasNoCafRefs, Unfolding: ("O"#) -}
223a85da46c93392bfafc9def26682718a0
224 $fShowSquare5 :: [GHC.Types.Char]
225 {- Unfolding: (GHC.CString.unpackCString# Main.$fShowSquare6) -}
2262ab4bcdf43d08eb2889562449df03bd4
227 $fShowSquare6 :: GHC.Prim.Addr#
228 {- HasNoCafRefs, Unfolding: ("Qu"#) -}
229e23edf746cf45789786f8cf7d218e23c
230 $fShowSquare7 :: [GHC.Types.Char]
231 {- Unfolding: (GHC.CString.unpackCString# Main.$fShowSquare8) -}
2320f48faaafde9dbcb6bdc9acd532c3d1f
233 $fShowSquare8 :: GHC.Prim.Addr#
234 {- HasNoCafRefs, Unfolding: ("X"#) -}
235636ccc849665ce7c3156c440898486e4
236 $fShowSquare_$cshow :: Main.Square -> GHC.Base.String
237 {- Arity: 1, Strictness: <S,1*U>,
238 Unfolding: InlineRule (1, True, False)
239 (\ (x :: Main.Square) ->
240 case x of wild {
241 Main.X -> Main.$fShowSquare7
242 Main.Qu -> Main.$fShowSquare5
243 Main.O -> Main.$fShowSquare3
244 Main.T -> Main.$fShowSquare1 }) -}
245636ccc849665ce7c3156c440898486e4
246 $fShowSquare_$cshowList :: [Main.Square] -> GHC.Show.ShowS
247 {- Arity: 2, Strictness: <S,1*U><L,U>,
248 Unfolding: InlineRule (2, True, False)
249 (\ (ls :: [Main.Square]) (s1 :: GHC.Base.String) ->
250 GHC.Show.showList__ @ Main.Square Main.$w$cshowsPrec ls s1) -}
251636ccc849665ce7c3156c440898486e4
252 $fShowSquare_$cshowsPrec ::
253 GHC.Types.Int -> Main.Square -> GHC.Show.ShowS
254 {- Arity: 3, Strictness: <L,A><S,1*U><L,1*U>, Inline: [2],
255 Unfolding: InlineRule (3, True, True)
256 (\ (w1 :: GHC.Types.Int)
257 (w2 :: Main.Square)
258 (w3 :: GHC.Base.String) ->
259 Main.$w$cshowsPrec w2 w3) -}
26016f9cbadd6cc253275bae13256416fc2
261 $s$fEq(,) :: GHC.Classes.Eq (GHC.Types.Int, GHC.Types.Int)
262 {- HasNoCafRefs, Strictness: m, Inline: CONLIKE,
263 Unfolding: DFun:.
264 @ (GHC.Types.Int, GHC.Types.Int)
265 (GHC.Classes.$fEq(,)_$c==
266 @ GHC.Types.Int
267 @ GHC.Types.Int
268 GHC.Classes.$fEqInt
269 GHC.Classes.$fEqInt)
270 Main.$s$fEq(,)_$s$fEq(,)_$c/= -}
271d9c29de69e24759049df94d820948480
272 $s$fEq(,)_$s$fEq(,)_$c/= ::
273 (GHC.Types.Int, GHC.Types.Int)
274 -> (GHC.Types.Int, GHC.Types.Int) -> GHC.Types.Bool
275 {- Arity: 2, HasNoCafRefs,
276 Strictness: <S(S(S)L),1*U(1*U(U),1*U(U))><S(S(S)L),1*U(1*U(U),1*U(U))>,
277 Inline: (sat-args=2),
278 Unfolding: InlineRule (2, False, False)
279 (\ (x :: (GHC.Types.Int, GHC.Types.Int))
280 (y :: (GHC.Types.Int, GHC.Types.Int)) ->
281 case x of wild { (,) a1 a2 ->
282 case y of wild1 { (,) b1 b2 ->
283 case GHC.Classes.eqInt a1 b1 of wild2 {
284 GHC.Types.False -> GHC.Types.True
285 GHC.Types.True
286 -> case GHC.Classes.eqInt a2 b2 of wild3 {
287 GHC.Types.False -> GHC.Types.True
288 GHC.Types.True -> GHC.Types.False } } } }) -}
289a5aa05036c6055a96ceac3d767cdd7d3
290 $ssubtract :: GHC.Types.Int -> GHC.Types.Int -> GHC.Types.Int
291 {- Arity: 2, HasNoCafRefs, Strictness: <S(S),1*U(U)><S(S),1*U(U)>m,
292 Inline: (sat-args=2),
293 Unfolding: InlineRule (2, False, True)
294 (\ (x :: GHC.Types.Int) (y :: GHC.Types.Int) ->
295 GHC.Num.$fNumInt_$c- y x) -}
2964b1b8958426064b7d9309d9d2fdefe7c
297 $ssubtract1 ::
298 GHC.Integer.Type.Integer
299 -> GHC.Integer.Type.Integer -> GHC.Integer.Type.Integer
300 {- Arity: 2, Strictness: <S,U><S,1*U>, Inline: (sat-args=2),
301 Unfolding: InlineRule (2, False, True)
302 (\ (x :: GHC.Integer.Type.Integer)
303 (y :: GHC.Integer.Type.Integer) ->
304 GHC.Integer.Type.minusInteger y x) -}
3056611e1da6e72881a60833105d1d890e3
306 $tc'O :: GHC.Types.TyCon
307 {- HasNoCafRefs, Strictness: m,
308 Unfolding: (GHC.Types.TyCon
309 9675801932394384788##
310 6712316648948115877##
311 Main.$trModule
312 Main.$tc'O2
313 0#
314 Main.$tc'O1) -}
315be5d1f5fee02b88e4232cb81c2af2579
316 $tc'O1 :: GHC.Types.KindRep
317 {- HasNoCafRefs, Strictness: m1, Inline: [~] -}
318ff261ad5b24f7fdd4296a33c047646a3
319 $tc'O2 :: GHC.Types.TrName
320 {- HasNoCafRefs, Strictness: m1,
321 Unfolding: (GHC.Types.TrNameS Main.$tc'O3) -}
322ef99b4220de234abd7b20254f6eb8a41
323 $tc'O3 :: GHC.Prim.Addr#
324 {- HasNoCafRefs, Unfolding: ("'O"#) -}
325ee107ec2d080306c47caa0ad45ca2789
326 $tc'Qu :: GHC.Types.TyCon
327 {- HasNoCafRefs, Strictness: m,
328 Unfolding: (GHC.Types.TyCon
329 17979074984894399304##
330 18119058677283552676##
331 Main.$trModule
332 Main.$tc'Qu1
333 0#
334 Main.$tc'O1) -}
335aa91b9b113b846476e7a8ca91ca447fa
336 $tc'Qu1 :: GHC.Types.TrName
337 {- HasNoCafRefs, Strictness: m1,
338 Unfolding: (GHC.Types.TrNameS Main.$tc'Qu2) -}
339ad8c06afed71d1de83408f6e00133f92
340 $tc'Qu2 :: GHC.Prim.Addr#
341 {- HasNoCafRefs, Unfolding: ("'Qu"#) -}
34241821a7de349be54ac630d2049b64a42
343 $tc'T :: GHC.Types.TyCon
344 {- HasNoCafRefs, Strictness: m,
345 Unfolding: (GHC.Types.TyCon
346 15564654814037795574##
347 9702549696965301893##
348 Main.$trModule
349 Main.$tc'T1
350 0#
351 Main.$tc'O1) -}
35282969608b13a211f112632f79676d867
353 $tc'T1 :: GHC.Types.TrName
354 {- HasNoCafRefs, Strictness: m1,
355 Unfolding: (GHC.Types.TrNameS Main.$tc'T2) -}
356187cc49652b02277d0b99ae5ea1a5fd9
357 $tc'T2 :: GHC.Prim.Addr#
358 {- HasNoCafRefs, Unfolding: ("'T"#) -}
359581a21f4a7e2a1d9b2996ff8c471b022
360 $tc'X :: GHC.Types.TyCon
361 {- HasNoCafRefs, Strictness: m,
362 Unfolding: (GHC.Types.TyCon
363 5225325308912582631##
364 14983302646393556978##
365 Main.$trModule
366 Main.$tc'X1
367 0#
368 Main.$tc'O1) -}
3693a2176738fada4904e3cf07296e7fdfd
370 $tc'X1 :: GHC.Types.TrName
371 {- HasNoCafRefs, Strictness: m1,
372 Unfolding: (GHC.Types.TrNameS Main.$tc'X2) -}
373568425ffbb1010e85481e6073e42496e
374 $tc'X2 :: GHC.Prim.Addr#
375 {- HasNoCafRefs, Unfolding: ("'X"#) -}
376dbf71b2385a61bc04046efc2d3fd1efc
377 $tcSquare :: GHC.Types.TyCon
378 {- HasNoCafRefs, Strictness: m,
379 Unfolding: (GHC.Types.TyCon
380 10164887948691462873##
381 15713138518001860047##
382 Main.$trModule
383 Main.$tcSquare1
384 0#
385 GHC.Types.krep$*) -}
386375635f77e678ce251c5463aacfeeccd
387 $tcSquare1 :: GHC.Types.TrName
388 {- HasNoCafRefs, Strictness: m1,
389 Unfolding: (GHC.Types.TrNameS Main.$tcSquare2) -}
39028ba19c10877e3323cf2c279f530ca96
391 $tcSquare2 :: GHC.Prim.Addr#
392 {- HasNoCafRefs, Unfolding: ("Square"#) -}
393be86c9d078d3acbf19ba91fe74a24273
394 $trModule :: GHC.Types.Module
395 {- HasNoCafRefs, Strictness: m,
396 Unfolding: (GHC.Types.Module Main.$trModule3 Main.$trModule1) -}
397b09d86f2c49dd5176b544d8d13ddb6c5
398 $trModule1 :: GHC.Types.TrName
399 {- HasNoCafRefs, Strictness: m1,
400 Unfolding: (GHC.Types.TrNameS Main.$trModule2) -}
401e5875966b74dad2d29772660b8a75e33
402 $trModule2 :: GHC.Prim.Addr#
403 {- HasNoCafRefs, Unfolding: ("Main"#) -}
40423b03bd7d075a00f5ad1ee10e6add7b8
405 $trModule3 :: GHC.Types.TrName
406 {- HasNoCafRefs, Strictness: m1,
407 Unfolding: (GHC.Types.TrNameS Main.$trModule4) -}
408d026be77cb9ced20e35a61514e0458aa
409 $trModule4 :: GHC.Prim.Addr#
410 {- HasNoCafRefs, Unfolding: ("main"#) -}
411636ccc849665ce7c3156c440898486e4
412 $w$cshowsPrec :: Main.Square -> GHC.Base.String -> GHC.Base.String
413 {- Arity: 2, Strictness: <S,1*U><L,1*U>, Inline: [2],
414 Unfolding: (\ (w1 :: Main.Square) (w2 :: GHC.Base.String) ->
415 case w1 of wild {
416 Main.X -> GHC.Base.++ @ GHC.Types.Char Main.$fShowSquare7 w2
417 Main.Qu -> GHC.Base.++ @ GHC.Types.Char Main.$fShowSquare5 w2
418 Main.O -> GHC.Base.++ @ GHC.Types.Char Main.$fShowSquare3 w2
419 Main.T -> GHC.Base.++ @ GHC.Types.Char Main.$fShowSquare1 w2 }) -}
42098dbe0ea72c75ba926317b7f7608e4d8
421 $wdiag ::
422 GHC.Prim.Int#
423 -> GHC.Types.Int
424 -> Data.Matrix.Matrix a
425 -> [(GHC.Types.Int, GHC.Types.Int)]
426 {- Arity: 3, HasNoCafRefs,
427 Strictness: <S,U><L,U(U)><L,U(U,U,A,A,A,A)>, Inline: [2],
428 Unfolding: (\ @ a
429 (ww :: GHC.Prim.Int#)
430 (ww1 :: GHC.Types.Int)
431 (w1 :: Data.Matrix.Matrix a) ->
432 let {
433 $wc :: (GHC.Types.Int -> GHC.Types.Int)
434 -> (GHC.Types.Int -> GHC.Types.Int)
435 -> [(GHC.Types.Int, GHC.Types.Int)]
436 {- Arity: 2, Strictness: <L,C(U(U))><L,C(U(U))>, Inline: [2] -}
437 = \ (ww2 :: GHC.Types.Int -> GHC.Types.Int)
438 (ww3 :: GHC.Types.Int -> GHC.Types.Int)[OneShot] ->
439 letrec {
440 $wgo2 :: GHC.Prim.Int#
441 -> GHC.Types.Int -> [(GHC.Types.Int, GHC.Types.Int)]
442 {- Arity: 2, Strictness: <S,U><L,1*U(U)>, Inline: [2] -}
443 = \ (ww4 :: GHC.Prim.Int#) (ww5 :: GHC.Types.Int) ->
444 case GHC.Prim.>=# ww4 1# of lwild {
445 DEFAULT -> GHC.Types.[] @ (GHC.Types.Int, GHC.Types.Int)
446 1#
447 -> case w1 of wild { Data.Matrix.M dt dt1 dt2 dt3 dt4 ds1 ->
448 case GHC.Prim.<=# ww4 dt of lwild1 {
449 DEFAULT -> GHC.Types.[] @ (GHC.Types.Int, GHC.Types.Int)
450 1#
451 -> case ww5 of wild1 { GHC.Types.I# x ->
452 case GHC.Prim.>=# x 1# of lwild2 {
453 DEFAULT -> GHC.Types.[] @ (GHC.Types.Int, GHC.Types.Int)
454 1#
455 -> case GHC.Prim.<=# x dt1 of lwild3 {
456 DEFAULT -> GHC.Types.[] @ (GHC.Types.Int, GHC.Types.Int)
457 1#
458 -> let {
459 i :: GHC.Types.Int = GHC.Types.I# ww4
460 } in
461 GHC.Types.:
462 @ (GHC.Types.Int, GHC.Types.Int)
463 (i, wild1)
464 (case ww2 i of ww6 { GHC.Types.I# ww7 ->
465 $wgo2 ww7 (ww3 wild1) }) } } } } } }
466 } in
467 $wgo2 ww ww1
468 } in
469 GHC.Base.++
470 @ (GHC.Types.Int, GHC.Types.Int)
471 ($wc Main.diag_a Main.diag_a)
472 (GHC.Base.++
473 @ (GHC.Types.Int, GHC.Types.Int)
474 ($wc Main.diag_a Main.diag_b)
475 (GHC.Base.++
476 @ (GHC.Types.Int, GHC.Types.Int)
477 ($wc Main.diag_b Main.diag_a)
478 (GHC.Base.++
479 @ (GHC.Types.Int, GHC.Types.Int)
480 ($wc Main.diag_b Main.diag_b)
481 (GHC.Types.[] @ (GHC.Types.Int, GHC.Types.Int)))))) -}
4822caee5b49997123c1e51e55e4c8a1465
483 $wdiag'' ::
484 (GHC.Num.Num b, GHC.Enum.Enum b, GHC.Num.Num a) =>
485 (a -> a -> [a]) -> a -> b -> [(a, b)]
486 {- Arity: 6, HasNoCafRefs,
487 Strictness: <L,U(A,A,A,A,A,A,C(U))><L,U(A,A,A,A,A,A,C(C1(U)),A)><L,U(A,A,A,A,A,A,C(U))><C(C(S)),C(C1(U))><L,U><L,U>,
488 Inline: [2] -}
489e7b8a501f5fd9578b49e2b724f683bc8
490 $wgetDiagL ::
491 GHC.Prim.Int# -> GHC.Types.Int -> Data.Matrix.Matrix a -> [a]
492 {- Arity: 3, Strictness: <S,U><L,U(U)><L,U(U,U,U,U,U,U(U,A,U))>,
493 Inline: [2],
494 Unfolding: (\ @ a
495 (ww :: GHC.Prim.Int#)
496 (ww1 :: GHC.Types.Int)
497 (w1 :: Data.Matrix.Matrix a) ->
498 GHC.Base.map
499 @ (GHC.Types.Int, GHC.Types.Int)
500 @ a
501 (\ (x :: (GHC.Types.Int, GHC.Types.Int)) -> Data.Matrix.! @ a w1 x)
502 (Main.$wdiag @ a ww ww1 w1)) -}
50311f7664f4ae85858621cfb12a0fb3060
504 $wgetRowColDiag ::
505 GHC.Types.Int
506 -> GHC.Types.Int
507 -> GHC.Prim.Int#
508 -> GHC.Prim.Int#
509 -> GHC.Prim.Int#
510 -> GHC.Prim.Int#
511 -> GHC.Prim.Int#
512 -> Data.Vector.Vector a
513 -> [((GHC.Types.Int, GHC.Types.Int), a)]
514 {- Arity: 8,
515 Strictness: <L,U(U)><L,U(U)><L,U><S,U><L,U><L,U><L,U><L,U(U,A,U)>,
516 Inline: [2] -}
517947a5776179f0c1f40c4a8ad30b9fd68
518 $wgo :: [Main.Square] -> GHC.Prim.Int# -> GHC.Types.Int
519 {- Arity: 2, HasNoCafRefs, Strictness: <S,1*U><S,U>m,
520 Inline: [2] -}
521715619f66da8ee3670b7cc69be050c49
522 $wisWinnable ::
523 GHC.Prim.Int# -> Data.Matrix.Matrix Main.Square -> GHC.Types.Bool
524 {- Arity: 2, Strictness: <S,U><L,U(U,U,U,U,U,U(U,A,U))>,
525 Inline: [2],
526 Unfolding: (\ (ww :: GHC.Prim.Int#)
527 (w1 :: Data.Matrix.Matrix Main.Square) ->
528 case GHC.Base.map
529 @ GHC.Types.Int
530 @ GHC.Types.Int
531 (\ (x :: GHC.Types.Int) ->
532 Main.$wgo (Main.getRowL @ Main.Square x w1) 0#)
533 Main.isWinnable1 of wild {
534 [] -> case GHC.List.maximum2 ret_ty GHC.Types.Bool of {}
535 : ipv ipv1
536 -> case ipv of ww1 { GHC.Types.I# ww2 ->
537 case GHC.List.$wgo ipv1 ww2 of ww3 { DEFAULT ->
538 case GHC.Prim.<=# ww ww3 of lwild {
539 DEFAULT -> GHC.Types.False
540 1#
541 -> case GHC.Base.map
542 @ GHC.Types.Int
543 @ GHC.Types.Int
544 (\ (x :: GHC.Types.Int) ->
545 Main.$wgo (Main.getColL @ Main.Square x w1) 0#)
546 Main.isWinnable1 of wild1 {
547 [] -> case GHC.List.maximum2 ret_ty GHC.Types.Bool of {}
548 : ipv2 ipv3
549 -> case ipv2 of ww4 { GHC.Types.I# ww5 ->
550 case GHC.List.$wgo ipv3 ww5 of ww6 { DEFAULT ->
551 GHC.Prim.tagToEnum#
552 @ GHC.Types.Bool
553 (GHC.Prim.<=# ww ww6) } } } } } } }) -}
55429e441a9726247d21b17947cf00c4bf0
555 $wisWinnable' :: Data.Matrix.Matrix Main.Square -> [GHC.Types.Char]
556 {- Arity: 1, Strictness: <L,U(U,U,U,U,U,U(U,A,U))>, Inline: [2],
557 Unfolding: (\ @ p (w1 :: Data.Matrix.Matrix Main.Square) ->
558 GHC.CString.unpackAppendCString#
559 Main.isWinnable'2
560 (case GHC.Base.map
561 @ GHC.Types.Int
562 @ GHC.Types.Int
563 (\ (x :: GHC.Types.Int) ->
564 Main.$wgo (Main.getRowL @ Main.Square x w1) 0#)
565 Main.isWinnable1 of wild {
566 [] -> case GHC.List.maximum2 ret_ty [GHC.Types.Char] of {}
567 : ipv ipv1
568 -> case ipv of ww { GHC.Types.I# ww1 ->
569 case GHC.List.$wgo ipv1 ww1 of ww2 { DEFAULT ->
570 case GHC.Show.$wshowSignedInt
571 0#
572 ww2
573 (GHC.Types.[] @ GHC.Types.Char) of ww4 { (#,#) ww5 ww6 ->
574 GHC.Base.++_$s++
575 @ GHC.Types.Char
576 (GHC.CString.unpackAppendCString#
577 Main.isWinnable'1
578 (case GHC.Base.map
579 @ GHC.Types.Int
580 @ GHC.Types.Int
581 (\ (x :: GHC.Types.Int) ->
582 Main.$wgo (Main.getColL @ Main.Square x w1) 0#)
583 Main.isWinnable1 of wild1 {
584 [] -> case GHC.List.maximum2 ret_ty [GHC.Types.Char] of {}
585 : ipv2 ipv3
586 -> case ipv2 of ww7 { GHC.Types.I# ww8 ->
587 case GHC.List.$wgo ipv3 ww8 of ww9 { DEFAULT ->
588 case GHC.Show.$wshowSignedInt
589 0#
590 ww9
591 (GHC.Types.[]
592 @ GHC.Types.Char) of ww10 { (#,#) ww11 ww12 ->
593 GHC.Types.: @ GHC.Types.Char ww11 ww12 } } } }))
594 ww5
595 ww6 } } } })) -}
5968247c69c6d133659d4fe141dff51dd1d
597 $wmapDiag ::
598 ((GHC.Types.Int, GHC.Types.Int) -> a -> a)
599 -> (GHC.Types.Int, GHC.Types.Int)
600 -> GHC.Prim.Int#
601 -> GHC.Prim.Int#
602 -> GHC.Prim.Int#
603 -> GHC.Prim.Int#
604 -> GHC.Prim.Int#
605 -> Data.Vector.Vector a
606 -> (# GHC.Prim.Int#, GHC.Prim.Int#, GHC.Prim.Int#, GHC.Prim.Int#,
607 GHC.Prim.Int#, Data.Vector.Vector a #)
608 {- Arity: 8,
609 Strictness: <L,C(C1(U))><L,1*U(1*U(U),U(U))><S,U><S,U><L,U><L,U><L,U><L,U(U,A,U)>,
610 Inline: [2] -}
611e1877462335ec1fb231f811fd98a6bec
612 $wmapRowColDiag ::
613 ((GHC.Types.Int, GHC.Types.Int) -> a -> a)
614 -> GHC.Types.Int
615 -> GHC.Types.Int
616 -> GHC.Prim.Int#
617 -> GHC.Prim.Int#
618 -> GHC.Prim.Int#
619 -> GHC.Prim.Int#
620 -> GHC.Prim.Int#
621 -> Data.Vector.Vector a
622 -> (# GHC.Prim.Int#, GHC.Prim.Int#, GHC.Prim.Int#, GHC.Prim.Int#,
623 GHC.Prim.Int#, Data.Vector.Vector a #)
624 {- Arity: 9,
625 Strictness: <L,C(C1(U))><L,U(U)><L,U(U)><S,U><S,U><L,U><L,U><L,U><L,U(U,A,U)>,
626 Inline: [2] -}
627d7372687809e115753d3bf6bcf601536
628 $wmarkX ::
629 (GHC.Types.Int, GHC.Types.Int)
630 -> GHC.Prim.Int#
631 -> GHC.Prim.Int#
632 -> GHC.Prim.Int#
633 -> GHC.Prim.Int#
634 -> GHC.Prim.Int#
635 -> Data.Vector.Vector Main.Square
636 -> (# GHC.Prim.Int#, GHC.Prim.Int#, GHC.Prim.Int#, GHC.Prim.Int#,
637 GHC.Prim.Int#, Data.Vector.Vector Main.Square #)
638 {- Arity: 7,
639 Strictness: <L,1*U(1*U(U),1*U(U))><S,U><S,U><S,U><S,U><S,U><L,1*U(U,U,U)>,
640 Inline: [2],
641 Unfolding: (\ (w1 :: (GHC.Types.Int, GHC.Types.Int))
642 (ww :: GHC.Prim.Int#)
643 (ww1 :: GHC.Prim.Int#)
644 (ww2 :: GHC.Prim.Int#)
645 (ww3 :: GHC.Prim.Int#)
646 (ww4 :: GHC.Prim.Int#)
647 (ww5 :: Data.Vector.Vector Main.Square) ->
648 (# ww, ww1, ww2, ww3, ww4,
649 case ww5 of v2 { Data.Vector.Vector ipv ipv1 ipv2 ->
650 case GHC.Magic.runRW#
651 @ ('GHC.Types.TupleRep
652 '[ 'GHC.Types.TupleRep '[], 'GHC.Types.LiftedRep])
653 @ (# GHC.Prim.State# GHC.Prim.RealWorld,
654 Data.Vector.Vector Main.Square #)
655 (\ (s1 :: GHC.Prim.State# GHC.Prim.RealWorld)[OneShot] ->
656 case GHC.Prim.>=# ipv1 0# of lwild {
657 DEFAULT
658 -> case Main.markX2 ipv1
659 ret_ty (# GHC.Prim.State# GHC.Prim.RealWorld,
660 Data.Vector.Vector Main.Square #)
661 of {}
662 1#
663 -> case GHC.Prim.newArray#
664 @ Main.Square
665 @ (Control.Monad.Primitive.PrimState
666 (GHC.ST.ST GHC.Prim.RealWorld))
667 ipv1
668 (Data.Vector.Mutable.uninitialised @ Main.Square)
669 s1
670 `cast`
671 (GHC.Prim.State#
672 (Sym (Control.Monad.Primitive.D:R:PrimStateST[0]
673 <GHC.Prim.RealWorld>_N)))_R of ds1 { (#,#) ipv3 ipv4 ->
674 case GHC.Prim.copyArray#
675 @ Main.Square
676 @ (Control.Monad.Primitive.PrimState
677 (GHC.ST.ST GHC.Prim.RealWorld))
678 ipv2
679 ipv
680 ipv4
681 0#
682 ipv1
683 ipv3 of s'# { DEFAULT ->
684 case w1 of wild2 { (,) i j ->
685 case i of wild3 { GHC.Types.I# x1 ->
686 case j of wild4 { GHC.Types.I# x2 ->
687 let {
688 x :: GHC.Prim.Int#
689 = GHC.Prim.-#
690 (GHC.Prim.+#
691 (GHC.Prim.*# (GHC.Prim.-# (GHC.Prim.+# x1 ww2) 1#) ww4)
692 (GHC.Prim.+# x2 ww3))
693 1#
694 } in
695 case GHC.Prim.>=# x 0# of lwild1 {
696 DEFAULT
697 -> case Main.markX1 @ GHC.Prim.RealWorld x ipv1
698 ret_ty (# GHC.Prim.State# GHC.Prim.RealWorld,
699 Data.Vector.Vector Main.Square #)
700 of {}
701 1#
702 -> case GHC.Prim.<# x ipv1 of lwild2 {
703 DEFAULT
704 -> case Main.markX1 @ GHC.Prim.RealWorld x ipv1
705 ret_ty (# GHC.Prim.State# GHC.Prim.RealWorld,
706 Data.Vector.Vector Main.Square #)
707 of {}
708 1#
709 -> case GHC.Prim.writeArray#
710 @ (Control.Monad.Primitive.PrimState
711 (GHC.ST.ST GHC.Prim.RealWorld))
712 @ Main.Square
713 ipv4
714 x
715 Main.X
716 s'# of s'#1 { DEFAULT ->
717 case GHC.Prim.unsafeFreezeArray#
718 @ (Control.Monad.Primitive.PrimState
719 (GHC.ST.ST GHC.Prim.RealWorld))
720 @ Main.Square
721 ipv4
722 s'#1 of ds2 { (#,#) ipv5 ipv6 ->
723 (# ipv5
724 `cast`
725 (GHC.Prim.State#
726 (Control.Monad.Primitive.D:R:PrimStateST[0]
727 <GHC.Prim.RealWorld>_N))_R,
728 Data.Vector.Vector
729 @ Main.Square
730 0#
731 ipv1
732 ipv6 #) } } } } } } } } } }) of ds1 { (#,#) ipv3 ipv4 ->
733 ipv4 } } #)) -}
7344085aa77d3428b41dae9dfa21d22b863
735 $wnextAvail ::
736 GHC.Prim.Int#
737 -> GHC.Prim.Int#
738 -> GHC.Prim.Int#
739 -> GHC.Prim.Int#
740 -> GHC.Prim.Int#
741 -> Data.Vector.Vector Main.Square
742 -> (GHC.Types.Int, GHC.Types.Int)
743 {- Arity: 6, Strictness: <S,U><S,U><S,U><S,U><S,U><L,U(U,A,U)>m,
744 Inline: [2],
745 Unfolding: (\ (ww :: GHC.Prim.Int#)
746 (ww1 :: GHC.Prim.Int#)
747 (ww2 :: GHC.Prim.Int#)
748 (ww3 :: GHC.Prim.Int#)
749 (ww4 :: GHC.Prim.Int#)
750 (ww5 :: Data.Vector.Vector Main.Square) ->
751 case Main.nextAvail_$sscanBoard
752 Main.O
753 (Data.Matrix.M @ Main.Square ww ww1 ww2 ww3 ww4 ww5) of wild {
754 [] -> GHC.List.badHead @ (GHC.Types.Int, GHC.Types.Int)
755 : y ys
756 -> case y of ww6 { (,) ww7 ww8 ->
757 letrec {
758 go1 :: [((GHC.Types.Int, GHC.Types.Int), Main.Square)]
759 -> (GHC.Types.Int, GHC.Types.Int)
760 <join 1> {- Arity: 1, Strictness: <S,1*U>m -}
761 = \ (ds :: [((GHC.Types.Int, GHC.Types.Int), Main.Square)]) ->
762 case ds of wild1 {
763 [] -> ww6
764 : y1 ys1
765 -> case y1 of wild2 { (,) ds1 y2 ->
766 case y2 of wild3 {
767 DEFAULT -> GHC.List.badHead @ (GHC.Types.Int, GHC.Types.Int)
768 Main.O -> go1 ys1 } } }
769 } in
770 go1
771 (Main.$wgetRowColDiag
772 @ Main.Square
773 ww7
774 ww8
775 ww
776 ww1
777 ww2
778 ww3
779 ww4
780 ww5) } }) -}
7812e97ede5368f9c2d2ff84f5bb17c4af3
782 $wplaceQueen ::
783 GHC.Types.Int
784 -> GHC.Types.Int
785 -> GHC.Prim.Int#
786 -> GHC.Prim.Int#
787 -> GHC.Prim.Int#
788 -> GHC.Prim.Int#
789 -> GHC.Prim.Int#
790 -> Data.Vector.Vector Main.Square
791 -> (# GHC.Prim.Int#, GHC.Prim.Int#, GHC.Prim.Int#, GHC.Prim.Int#,
792 GHC.Prim.Int#, Data.Vector.Vector Main.Square #)
793 {- Arity: 8,
794 Strictness: <L,U(U)><L,U(U)><S,U><S,U><S,U><S,U><S,U><L,U(U,A,U)>,
795 Inline: [2],
796 Unfolding: (\ (ww :: GHC.Types.Int)
797 (ww1 :: GHC.Types.Int)
798 (ww2 :: GHC.Prim.Int#)
799 (ww3 :: GHC.Prim.Int#)
800 (ww4 :: GHC.Prim.Int#)
801 (ww5 :: GHC.Prim.Int#)
802 (ww6 :: GHC.Prim.Int#)
803 (ww7 :: Data.Vector.Vector Main.Square) ->
804 case Main.$wmapRowColDiag
805 @ Main.Square
806 Main.placeQueen1
807 ww
808 ww1
809 ww2
810 ww3
811 ww4
812 ww5
813 ww6
814 ww7 of ww8 { (#,,,,,#) ww9 ww10 ww11 ww12 ww13 ww14 ->
815 (# ww9, ww10, ww11, ww12, ww13,
816 case ww14 of v2 { Data.Vector.Vector ipv ipv1 ipv2 ->
817 case GHC.Magic.runRW#
818 @ ('GHC.Types.TupleRep
819 '[ 'GHC.Types.TupleRep '[], 'GHC.Types.LiftedRep])
820 @ (# GHC.Prim.State# GHC.Prim.RealWorld,
821 Data.Vector.Vector Main.Square #)
822 (\ (s1 :: GHC.Prim.State# GHC.Prim.RealWorld)[OneShot] ->
823 case GHC.Prim.>=# ipv1 0# of lwild {
824 DEFAULT
825 -> case Main.markX2 ipv1
826 ret_ty (# GHC.Prim.State# GHC.Prim.RealWorld,
827 Data.Vector.Vector Main.Square #)
828 of {}
829 1#
830 -> case GHC.Prim.newArray#
831 @ Main.Square
832 @ (Control.Monad.Primitive.PrimState
833 (GHC.ST.ST GHC.Prim.RealWorld))
834 ipv1
835 (Data.Vector.Mutable.uninitialised @ Main.Square)
836 s1
837 `cast`
838 (GHC.Prim.State#
839 (Sym (Control.Monad.Primitive.D:R:PrimStateST[0]
840 <GHC.Prim.RealWorld>_N)))_R of ds1 { (#,#) ipv3 ipv4 ->
841 case GHC.Prim.copyArray#
842 @ Main.Square
843 @ (Control.Monad.Primitive.PrimState
844 (GHC.ST.ST GHC.Prim.RealWorld))
845 ipv2
846 ipv
847 ipv4
848 0#
849 ipv1
850 ipv3 of s'# { DEFAULT ->
851 case ww of wild3 { GHC.Types.I# x1 ->
852 case ww1 of wild4 { GHC.Types.I# x2 ->
853 let {
854 x :: GHC.Prim.Int#
855 = GHC.Prim.-#
856 (GHC.Prim.+#
857 (GHC.Prim.*# (GHC.Prim.-# (GHC.Prim.+# x1 ww11) 1#) ww13)
858 (GHC.Prim.+# x2 ww12))
859 1#
860 } in
861 case GHC.Prim.>=# x 0# of lwild1 {
862 DEFAULT
863 -> case Main.markX1 @ GHC.Prim.RealWorld x ipv1
864 ret_ty (# GHC.Prim.State# GHC.Prim.RealWorld,
865 Data.Vector.Vector Main.Square #)
866 of {}
867 1#
868 -> case GHC.Prim.<# x ipv1 of lwild2 {
869 DEFAULT
870 -> case Main.markX1 @ GHC.Prim.RealWorld x ipv1
871 ret_ty (# GHC.Prim.State# GHC.Prim.RealWorld,
872 Data.Vector.Vector Main.Square #)
873 of {}
874 1#
875 -> case GHC.Prim.writeArray#
876 @ (Control.Monad.Primitive.PrimState
877 (GHC.ST.ST GHC.Prim.RealWorld))
878 @ Main.Square
879 ipv4
880 x
881 Main.Qu
882 s'# of s'#1 { DEFAULT ->
883 case GHC.Prim.unsafeFreezeArray#
884 @ (Control.Monad.Primitive.PrimState
885 (GHC.ST.ST GHC.Prim.RealWorld))
886 @ Main.Square
887 ipv4
888 s'#1 of ds2 { (#,#) ipv5 ipv6 ->
889 (# ipv5
890 `cast`
891 (GHC.Prim.State#
892 (Control.Monad.Primitive.D:R:PrimStateST[0]
893 <GHC.Prim.RealWorld>_N))_R,
894 Data.Vector.Vector
895 @ Main.Square
896 0#
897 ipv1
898 ipv6 #) } } } } } } } } }) of ds1 { (#,#) ipv3 ipv4 ->
899 ipv4 } } #) }) -}
9008ef5fa9322c84b90e14eaeb7d5987990
901 $wplaceQueen' ::
902 GHC.Types.Int
903 -> GHC.Types.Int
904 -> GHC.Prim.Int#
905 -> GHC.Prim.Int#
906 -> GHC.Prim.Int#
907 -> GHC.Prim.Int#
908 -> GHC.Prim.Int#
909 -> Data.Vector.Vector Main.Square
910 -> (# GHC.Prim.Int#, GHC.Prim.Int#, GHC.Prim.Int#, GHC.Prim.Int#,
911 GHC.Prim.Int#, Data.Vector.Vector Main.Square #)
912 {- Arity: 8,
913 Strictness: <L,U(U)><L,U(U)><S,U><S,U><S,U><S,U><S,U><L,U(U,A,U)>,
914 Inline: [2],
915 Unfolding: (\ (ww :: GHC.Types.Int)
916 (ww1 :: GHC.Types.Int)
917 (ww2 :: GHC.Prim.Int#)
918 (ww3 :: GHC.Prim.Int#)
919 (ww4 :: GHC.Prim.Int#)
920 (ww5 :: GHC.Prim.Int#)
921 (ww6 :: GHC.Prim.Int#)
922 (ww7 :: Data.Vector.Vector Main.Square) ->
923 case Data.Matrix.$wmapCol
924 @ Main.Square
925 (Main.placeQueen'_fX @ GHC.Types.Int @ Main.Square)
926 ww1
927 ww2
928 ww3
929 ww4
930 ww5
931 ww6
932 ww7 of ww8 { (#,,,,,#) ww9 ww10 ww11 ww12 ww13 ww14 ->
933 case Data.Matrix.$wmapRow
934 @ Main.Square
935 (Main.placeQueen'_fX @ GHC.Types.Int @ Main.Square)
936 ww
937 ww9
938 ww10
939 ww11
940 ww12
941 ww13
942 ww14 of ww15 { (#,,,,,#) ww16 ww17 ww18 ww19 ww20 ww21 ->
943 (# ww16, ww17, ww18, ww19, ww20,
944 case ww21 of v2 { Data.Vector.Vector ipv ipv1 ipv2 ->
945 case GHC.Magic.runRW#
946 @ ('GHC.Types.TupleRep
947 '[ 'GHC.Types.TupleRep '[], 'GHC.Types.LiftedRep])
948 @ (# GHC.Prim.State# GHC.Prim.RealWorld,
949 Data.Vector.Vector Main.Square #)
950 (\ (s1 :: GHC.Prim.State# GHC.Prim.RealWorld)[OneShot] ->
951 case GHC.Prim.>=# ipv1 0# of lwild {
952 DEFAULT
953 -> case Main.markX2 ipv1
954 ret_ty (# GHC.Prim.State# GHC.Prim.RealWorld,
955 Data.Vector.Vector Main.Square #)
956 of {}
957 1#
958 -> case GHC.Prim.newArray#
959 @ Main.Square
960 @ (Control.Monad.Primitive.PrimState
961 (GHC.ST.ST GHC.Prim.RealWorld))
962 ipv1
963 (Data.Vector.Mutable.uninitialised @ Main.Square)
964 s1
965 `cast`
966 (GHC.Prim.State#
967 (Sym (Control.Monad.Primitive.D:R:PrimStateST[0]
968 <GHC.Prim.RealWorld>_N)))_R of ds1 { (#,#) ipv3 ipv4 ->
969 case GHC.Prim.copyArray#
970 @ Main.Square
971 @ (Control.Monad.Primitive.PrimState
972 (GHC.ST.ST GHC.Prim.RealWorld))
973 ipv2
974 ipv
975 ipv4
976 0#
977 ipv1
978 ipv3 of s'# { DEFAULT ->
979 case ww of wild3 { GHC.Types.I# x1 ->
980 case ww1 of wild4 { GHC.Types.I# x2 ->
981 let {
982 x :: GHC.Prim.Int#
983 = GHC.Prim.-#
984 (GHC.Prim.+#
985 (GHC.Prim.*# (GHC.Prim.-# (GHC.Prim.+# x1 ww18) 1#) ww20)
986 (GHC.Prim.+# x2 ww19))
987 1#
988 } in
989 case GHC.Prim.>=# x 0# of lwild1 {
990 DEFAULT
991 -> case Main.markX1 @ GHC.Prim.RealWorld x ipv1
992 ret_ty (# GHC.Prim.State# GHC.Prim.RealWorld,
993 Data.Vector.Vector Main.Square #)
994 of {}
995 1#
996 -> case GHC.Prim.<# x ipv1 of lwild2 {
997 DEFAULT
998 -> case Main.markX1 @ GHC.Prim.RealWorld x ipv1
999 ret_ty (# GHC.Prim.State# GHC.Prim.RealWorld,
1000 Data.Vector.Vector Main.Square #)
1001 of {}
1002 1#
1003 -> case GHC.Prim.writeArray#
1004 @ (Control.Monad.Primitive.PrimState
1005 (GHC.ST.ST GHC.Prim.RealWorld))
1006 @ Main.Square
1007 ipv4
1008 x
1009 Main.Qu
1010 s'# of s'#1 { DEFAULT ->
1011 case GHC.Prim.unsafeFreezeArray#
1012 @ (Control.Monad.Primitive.PrimState
1013 (GHC.ST.ST GHC.Prim.RealWorld))
1014 @ Main.Square
1015 ipv4
1016 s'#1 of ds2 { (#,#) ipv5 ipv6 ->
1017 (# ipv5
1018 `cast`
1019 (GHC.Prim.State#
1020 (Control.Monad.Primitive.D:R:PrimStateST[0]
1021 <GHC.Prim.RealWorld>_N))_R,
1022 Data.Vector.Vector
1023 @ Main.Square
1024 0#
1025 ipv1
1026 ipv6 #) } } } } } } } } }) of ds1 { (#,#) ipv3 ipv4 ->
1027 ipv4 } } #) } }) -}
1028c57b742ed68452b2e8b2cded00e72e1c
1029 $wsolve ::
1030 GHC.Classes.Eq t =>
1031 (t -> t -> GHC.Types.Bool)
1032 -> (t -> t -> GHC.Types.Bool)
1033 -> GHC.Num.Num t => t -> [Data.Matrix.Matrix Main.Square]
1034 {- Arity: 5,
1035 Strictness: <L,1*U(C(C1(U)),A)><C(C(S)),1*C1(C1(U))><L,1*C1(C1(U))><L,U(A,C(C1(U)),A,A,A,A,C(U))><L,U>,
1036 Inline: [2],
1037 Unfolding: (\ @ t
1038 (ww :: GHC.Classes.Eq t)
1039 (ww1 :: t -> t -> GHC.Types.Bool)
1040 (ww2 :: t -> t -> GHC.Types.Bool)
1041 (w1 :: GHC.Num.Num t)
1042 (w2 :: t) ->
1043 case ww1 w2 (GHC.Num.fromInteger @ t w1 Main.ops5) of wild {
1044 GHC.Types.False
1045 -> case ww2 w2 (GHC.Num.fromInteger @ t w1 Main.lo1) of wild1 {
1046 GHC.Types.False
1047 -> case ww of ww3 { GHC.Classes.C:Eq ww4 ww5 ->
1048 let {
1049 lvl12 :: t = GHC.Num.fromInteger @ t w1 Main.ops5
1050 } in
1051 let {
1052 lvl13 :: t = GHC.Num.fromInteger @ t w1 Main.lo2
1053 } in
1054 letrec {
1055 solveN :: t -> [Data.Matrix.Matrix Main.Square]
1056 {- Arity: 1, Strictness: <L,U> -}
1057 = \ (ds :: t) ->
1058 case ww4 ds lvl13 of wild2 {
1059 GHC.Types.False
1060 -> case ww4 ds lvl12 of wild3 {
1061 GHC.Types.False
1062 -> Main.solve_go (solveN (GHC.Num.- @ t w1 ds lvl12))
1063 GHC.Types.True -> Main.solve1 }
1064 GHC.Types.True -> GHC.Types.[] @ (Data.Matrix.Matrix Main.Square) }
1065 } in
1066 solveN w2 }
1067 GHC.Types.True -> GHC.Types.[] @ (Data.Matrix.Matrix Main.Square) }
1068 GHC.Types.True
1069 -> GHC.Types.[] @ (Data.Matrix.Matrix Main.Square) }) -}
1070f5d40babaf79dc225afeeacf39e71d14
1071 $wwinners ::
1072 (p -> p -> GHC.Types.Bool)
1073 -> GHC.Num.Num p =>
1074 p
1075 -> [Data.Matrix.Matrix Main.Square]
1076 -> [Data.Matrix.Matrix Main.Square]
1077 {- Arity: 4,
1078 Strictness: <C(C(S)),C(C1(U))><L,U(A,C(C1(U)),A,A,A,A,1*C1(U))><L,U><S,1*U>,
1079 Inline: [2],
1080 Unfolding: (\ @ p
1081 (ww :: p -> p -> GHC.Types.Bool)
1082 (w1 :: GHC.Num.Num p)
1083 (w2 :: p)
1084 (w3 :: [Data.Matrix.Matrix Main.Square]) ->
1085 let {
1086 lvl12 :: p = GHC.Num.fromInteger @ p w1 Main.ops5
1087 } in
1088 letrec {
1089 winners2 :: p
1090 -> [Data.Matrix.Matrix Main.Square]
1091 -> [Data.Matrix.Matrix Main.Square]
1092 <join 2> {- Arity: 2, Strictness: <L,U><S,1*U> -}
1093 = \ (ds :: p) (b :: [Data.Matrix.Matrix Main.Square]) ->
1094 case ww ds lvl12 of wild {
1095 GHC.Types.False
1096 -> winners2 (GHC.Num.- @ p w1 ds lvl12) (Main.winners1 @ p b)
1097 GHC.Types.True -> Main.winners_go b }
1098 } in
1099 winners2 w2 w3) -}
1100fc231a19666745198b5cad6fbcf77735
1101 $wwinners' ::
1102 Data.Matrix.Matrix Main.Square -> [Data.Matrix.Matrix Main.Square]
1103 {- Arity: 1, Strictness: <L,U(U,U,U,U,U,U(U,A,U))>, Inline: [2],
1104 Unfolding: (\ @ p (w1 :: Data.Matrix.Matrix Main.Square) ->
1105 letrec {
1106 go1 :: [(GHC.Types.Int, GHC.Types.Int)]
1107 -> [Data.Matrix.Matrix Main.Square]
1108 {- Arity: 1, Strictness: <S,1*U> -}
1109 = \ (ds :: [(GHC.Types.Int, GHC.Types.Int)]) ->
1110 case ds of wild {
1111 [] -> GHC.Types.[] @ (Data.Matrix.Matrix Main.Square)
1112 : y ys
1113 -> case y of ww { (,) ww1 ww2 ->
1114 case w1 of ww3 { Data.Matrix.M ww4 ww5 ww6 ww7 ww8 ww9 ->
1115 let {
1116 exit :: [Data.Matrix.Matrix Main.Square] <join 0>
1117 = GHC.Types.:
1118 @ (Data.Matrix.Matrix Main.Square)
1119 (case Main.$wplaceQueen
1120 ww1
1121 ww2
1122 ww4
1123 ww5
1124 ww6
1125 ww7
1126 ww8
1127 ww9 of ww10 { (#,,,,,#) ww11 ww12 ww13 ww14 ww15 ww16 ->
1128 Data.Matrix.M @ Main.Square ww11 ww12 ww13 ww14 ww15 ww16 })
1129 (go1 ys)
1130 } in
1131 let {
1132 exit1 :: [Data.Matrix.Matrix Main.Square] <join 0> = go1 ys
1133 } in
1134 letrec {
1135 go2 :: [((GHC.Types.Int, GHC.Types.Int), Main.Square)]
1136 -> [Data.Matrix.Matrix Main.Square]
1137 <join 1> {- Arity: 1, Strictness: <S,1*U> -}
1138 = \ (ds1 :: [((GHC.Types.Int, GHC.Types.Int), Main.Square)]) ->
1139 case ds1 of wild1 {
1140 [] -> exit
1141 : y1 ys1
1142 -> case y1 of wild2 { (,) ds2 y2 ->
1143 case y2 of wild3 { DEFAULT -> exit1 Main.O -> go2 ys1 } } }
1144 } in
1145 go2
1146 (Main.$wgetRowColDiag
1147 @ Main.Square
1148 ww1
1149 ww2
1150 ww4
1151 ww5
1152 ww6
1153 ww7
1154 ww8
1155 ww9) } } }
1156 } in
1157 go1 (Main.nextAvail_$sscanBoard Main.O w1)) -}
1158636ccc849665ce7c3156c440898486e4
1159 data Square = X | Qu | O | T
1160e6f15f421e1dad77000d8fc6a4ea855b
1161 allPositions :: [(GHC.Types.Int, GHC.Types.Int)]
1162 {- Unfolding: (Main.allPositions_go 1#) -}
1163346f770a613a5360df15e8c985bdce13
1164 allPositions_go ::
1165 GHC.Prim.Int# -> [(GHC.Types.Int, GHC.Types.Int)]
1166 {- Arity: 1, HasNoCafRefs, Strictness: <L,U> -}
1167194ce8b8e7f8d37be79aac8aa28e9d44
1168 allops :: b -> b -> [(b, b)]
1169 {- Arity: 2, HasNoCafRefs, Strictness: <L,U><L,U>m2,
1170 Unfolding: InlineRule (2, True, False)
1171 (\ @ b (a :: b) (b1 :: b) ->
1172 GHC.Types.:
1173 @ (b, b)
1174 (a, a)
1175 (GHC.Types.:
1176 @ (b, b)
1177 (a, b1)
1178 (GHC.Types.:
1179 @ (b, b)
1180 (b1, a)
1181 (GHC.Types.: @ (b, b) (b1, b1) (GHC.Types.[] @ (b, b)))))) -}
11821510beb52847e90895824612d049f264
1183 applyop :: (t1, t2) -> (t1 -> a, t2 -> b) -> (a, b)
1184 {- Arity: 2, HasNoCafRefs,
1185 Strictness: <S,1*U(U,U)><S,1*U(1*C1(U),1*C1(U))>m,
1186 Unfolding: InlineRule (2, True, False)
1187 (\ @ t @ t1 @ a @ b (ds :: (t, t1)) (ds1 :: (t -> a, t1 -> b)) ->
1188 case ds of wild { (,) x y ->
1189 case ds1 of wild1 { (,) a1 b1 -> (a1 x, b1 y) } }) -}
11906f09b815b2eac49fd5e364003153edb6
1191 applyops ::
1192 (GHC.Integer.Type.Integer, GHC.Integer.Type.Integer)
1193 -> [(GHC.Integer.Type.Integer, GHC.Integer.Type.Integer)]
1194 {- Arity: 1, Strictness: <L,U(U,U)>,
1195 Unfolding: InlineRule (1, True, False)
1196 (\ (p :: (GHC.Integer.Type.Integer, GHC.Integer.Type.Integer)) ->
1197 GHC.Base.build
1198 @ (GHC.Integer.Type.Integer, GHC.Integer.Type.Integer)
1199 (\ @ b1
1200 (c :: (GHC.Integer.Type.Integer, GHC.Integer.Type.Integer)
1201 -> b1 -> b1)[OneShot]
1202 (n :: b1)[OneShot] ->
1203 GHC.Base.foldr
1204 @ (GHC.Integer.Type.Integer -> GHC.Integer.Type.Integer,
1205 GHC.Integer.Type.Integer -> GHC.Integer.Type.Integer)
1206 @ b1
1207 (GHC.Base.mapFB
1208 @ (GHC.Integer.Type.Integer, GHC.Integer.Type.Integer)
1209 @ b1
1210 @ (GHC.Integer.Type.Integer -> GHC.Integer.Type.Integer,
1211 GHC.Integer.Type.Integer -> GHC.Integer.Type.Integer)
1212 c
1213 (Main.applyop
1214 @ GHC.Integer.Type.Integer
1215 @ GHC.Integer.Type.Integer
1216 @ GHC.Integer.Type.Integer
1217 @ GHC.Integer.Type.Integer
1218 p))
1219 n
1220 Main.ops)) -}
12213d3675529761c115a8648803688b15f0
1222 diag ::
1223 (GHC.Types.Int, GHC.Types.Int)
1224 -> Data.Matrix.Matrix a -> [(GHC.Types.Int, GHC.Types.Int)]
1225 {- Arity: 2, HasNoCafRefs,
1226 Strictness: <S(S(S)L),1*U(1*U(U),U(U))><L,U(U,U,A,A,A,A)>,
1227 Inline: [2],
1228 Unfolding: InlineRule (2, True, False)
1229 (\ @ a
1230 (w1 :: (GHC.Types.Int, GHC.Types.Int))
1231 (w2 :: Data.Matrix.Matrix a) ->
1232 case w1 of ww { (,) ww1 ww2 ->
1233 case ww1 of ww3 { GHC.Types.I# ww4 ->
1234 Main.$wdiag @ a ww4 ww2 w2 } }) -}
1235521caf14a897d9945170c2a83c7838bf
1236 diag'' ::
1237 (GHC.Num.Num b, GHC.Enum.Enum b, GHC.Num.Num a, GHC.Enum.Enum a) =>
1238 a -> b -> [(a, b)]
1239 {- Arity: 6, HasNoCafRefs,
1240 Strictness: <L,U(A,A,A,A,A,A,C(U))><L,U(A,A,A,A,A,A,C(C1(U)),A)><L,U(A,A,A,A,A,A,C(U))><S(LLLLLLC(C(S))L),1*U(A,A,A,A,A,A,C(C1(U)),A)><L,U><L,U>,
1241 Inline: [2],
1242 Unfolding: InlineRule (6, True, False)
1243 (\ @ b
1244 @ a
1245 (w1 :: GHC.Num.Num b)
1246 (w2 :: GHC.Enum.Enum b)
1247 (w3 :: GHC.Num.Num a)
1248 (w4 :: GHC.Enum.Enum a)
1249 (w5 :: a)
1250 (w6 :: b) ->
1251 case w4 of ww { GHC.Enum.C:Enum ww1 ww2 ww3 ww4 ww5 ww6 ww7 ww8 ->
1252 Main.$wdiag'' @ b @ a w1 w2 w3 ww7 w5 w6 }) -}
12532189f869b91b6ccf81bf4b6df23487af
1254 diag1 :: GHC.Types.Int
1255 {- HasNoCafRefs, Strictness: m, Unfolding: (GHC.Types.I# 1#) -}
12564813f5027120582dc077480ee2be320f
1257 diag_a :: GHC.Types.Int -> GHC.Types.Int
1258 {- Arity: 1, HasNoCafRefs, Strictness: <S(S),1*U(U)>m,
1259 Unfolding: InlineRule (1, True, False)
1260 (\ (ds :: GHC.Types.Int) ->
1261 case ds of wild { GHC.Types.I# x ->
1262 GHC.Types.I# (GHC.Prim.+# x 1#) }) -}
126390a1a91fcfdff7b345d5ba6f915f51fe
1264 diag_b :: GHC.Types.Int -> GHC.Types.Int
1265 {- Arity: 1, HasNoCafRefs,
1266 Unfolding: (Main.$ssubtract Main.diag1) -}
1267d565538a2eaa3b46fc2f853fadab9e26
1268 getColL :: GHC.Types.Int -> Data.Matrix.Matrix b -> [b]
1269 {- Arity: 2, Strictness: <L,U(U)><L,U(U,U,U,U,U,U(U,A,U))>,
1270 Unfolding: (\ @ b
1271 (c :: GHC.Types.Int)
1272 (b1 :: Data.Matrix.Matrix b) ->
1273 let {
1274 lvl12 :: GHC.Base.String
1275 = GHC.Show.$fShow(,)_$sgo1
1276 Main.getColL17
1277 (\ (w2 :: GHC.Base.String)[OneShot] ->
1278 case c of ww2 { GHC.Types.I# ww3 ->
1279 case GHC.Show.$wshowSignedInt 0# ww3 w2 of ww4 { (#,#) ww5 ww6 ->
1280 GHC.Types.: @ GHC.Types.Char ww5 ww6 } })
1281 (GHC.Types.[] @ GHC.Show.ShowS)
1282 } in
1283 let {
1284 lvl13 :: [GHC.Types.Char]
1285 = GHC.Types.: @ GHC.Types.Char GHC.Show.showList__1 lvl12
1286 } in
1287 letrec {
1288 go1 :: GHC.Prim.Int# -> [b] {- Arity: 1, Strictness: <L,U> -}
1289 = \ (x :: GHC.Prim.Int#) ->
1290 GHC.Types.:
1291 @ b
1292 (case b1 of wild { Data.Matrix.M dt dt1 dt2 dt3 dt4 ds ->
1293 let {
1294 $j :: b <join 0> {- Strictness: x -}
1295 = GHC.Err.error
1296 @ 'GHC.Types.LiftedRep
1297 @ b
1298 Main.getColL3
1299 `cast`
1300 (Sym (GHC.Classes.N:IP[0]
1301 <"callStack">_N <GHC.Stack.Types.CallStack>_N))
1302 (GHC.CString.unpackAppendCString#
1303 Main.getColL2
1304 (let {
1305 z :: [GHC.Types.Char]
1306 = GHC.CString.unpackAppendCString#
1307 Main.getColL1
1308 (case Data.Matrix.$wsizeStr
1309 dt
1310 (GHC.Types.I# dt1) of ww2 { (#,#) ww3 ww4 ->
1311 Main.getColL_go (GHC.Types.: @ GHC.Types.Char ww3 ww4) })
1312 } in
1313 letrec {
1314 go2 :: [GHC.Types.Char] -> [GHC.Types.Char]
1315 {- Arity: 1, Strictness: <S,1*U> -}
1316 = \ (ds1 :: [GHC.Types.Char]) ->
1317 case ds1 of wild1 {
1318 [] -> z : y ys -> GHC.Types.: @ GHC.Types.Char y (go2 ys) }
1319 } in
1320 go2
1321 (GHC.Types.:
1322 @ GHC.Types.Char
1323 GHC.Show.$fShow(,)4
1324 (case GHC.Show.$wshowSignedInt
1325 0#
1326 x
1327 lvl13 of ww4 { (#,#) ww5 ww6 ->
1328 GHC.Types.: @ GHC.Types.Char ww5 ww6 }))))
1329 } in
1330 case GHC.Prim.># x dt of lwild {
1331 DEFAULT
1332 -> case c of wild2 { GHC.Types.I# x1 ->
1333 case GHC.Prim.># x1 dt1 of lwild1 {
1334 DEFAULT
1335 -> case GHC.Prim.<# x 1# of lwild2 {
1336 DEFAULT
1337 -> case GHC.Prim.<# x1 1# of lwild3 {
1338 DEFAULT
1339 -> case ds of wild3 { Data.Vector.Vector dt5 dt6 dt7 ->
1340 case GHC.Prim.indexArray#
1341 @ b
1342 dt7
1343 (GHC.Prim.-#
1344 (GHC.Prim.+#
1345 dt5
1346 (GHC.Prim.+#
1347 (GHC.Prim.*#
1348 (GHC.Prim.-# (GHC.Prim.+# x dt2) 1#)
1349 dt4)
1350 (GHC.Prim.+# x1 dt3)))
1351 1#) of ds2 { Unit# ipv ->
1352 ipv } }
1353 1# -> $j }
1354 1# -> $j }
1355 1# -> $j } }
1356 1# -> $j } })
1357 (case x of wild {
1358 DEFAULT -> go1 (GHC.Prim.+# wild 1#) 8# -> GHC.Types.[] @ b })
1359 } in
1360 go1 1#) -}
136159a3d6e7a7d530f2d5917c5d492ef742
1362 getColL1 :: GHC.Prim.Addr#
1363 {- HasNoCafRefs, Unfolding: (" element from a "#) -}
13647b742804a973a371e3e88e2b04b6943d
1365 getColL10 :: GHC.Prim.Addr#
1366 {- HasNoCafRefs, Unfolding: ("./Data/Matrix.hs"#) -}
136716a55bd560443de3787e26963c224d00
1368 getColL11 :: [GHC.Types.Char]
1369 {- Unfolding: (GHC.CString.unpackCString# Main.getColL12) -}
137049b261779522cf2cb70b366e5468ac70
1371 getColL12 :: GHC.Prim.Addr#
1372 {- HasNoCafRefs, Unfolding: ("Data.Matrix"#) -}
137392b62b416ca035d74d9f76c2d45db080
1374 getColL13 :: [GHC.Types.Char]
1375 {- Unfolding: (GHC.CString.unpackCString# Main.getColL14) -}
1376d70fe03047f9d5d1fbd4af4cf9015d44
1377 getColL14 :: GHC.Prim.Addr#
1378 {- HasNoCafRefs,
1379 Unfolding: ("matrix-0.3.6.1-CUcUqfmsmAA7saz436AQSk"#) -}
13803231f8c7d8c0936ef4d69ce873202d4f
1381 getColL15 :: [GHC.Types.Char]
1382 {- Unfolding: (GHC.CString.unpackCString# Main.getColL16) -}
1383c23d90f9195be571da707594d1a5f451
1384 getColL16 :: GHC.Prim.Addr#
1385 {- HasNoCafRefs, Unfolding: ("error"#) -}
1386ff1980320d786af053c918c56beea394
1387 getColL17 :: [GHC.Types.Char]
1388 {- HasNoCafRefs, Strictness: m2,
1389 Unfolding: (GHC.Types.:
1390 @ GHC.Types.Char
1391 GHC.Show.$fShow(,)2
1392 (GHC.Types.[] @ GHC.Types.Char)) -}
139379518a96650d201c5f67e67a4db3cb67
1394 getColL2 :: GHC.Prim.Addr#
1395 {- HasNoCafRefs, Unfolding: ("getElem: Trying to get the "#) -}
13965619add454821844124a1652165aec69
1397 getColL3 :: GHC.Stack.Types.CallStack
1398 {- Strictness: m2,
1399 Unfolding: (GHC.Stack.Types.PushCallStack
1400 Main.getColL15
1401 Main.getColL4
1402 GHC.Stack.Types.EmptyCallStack) -}
1403eeb651480663ce22e6859c5904879429
1404 getColL4 :: GHC.Stack.Types.SrcLoc
1405 {- Strictness: m,
1406 Unfolding: (GHC.Stack.Types.SrcLoc
1407 Main.getColL13
1408 Main.getColL11
1409 Main.getColL9
1410 Main.getColL8
1411 Main.getColL7
1412 Main.getColL6
1413 Main.getColL5) -}
1414de832c74ff8c2a95f2e64d0ce59ab379
1415 getColL5 :: GHC.Types.Int
1416 {- HasNoCafRefs, Strictness: m, Unfolding: (GHC.Types.I# 22#) -}
14176cbddb6b2bd4ca54512efe418fc3f972
1418 getColL6 :: GHC.Types.Int
1419 {- HasNoCafRefs, Strictness: m, Unfolding: (GHC.Types.I# 456#) -}
14206ebdb60bb88d05048f3b0d9a4cfa8ea5
1421 getColL7 :: GHC.Types.Int
1422 {- HasNoCafRefs, Strictness: m, Unfolding: (GHC.Types.I# 6#) -}
1423fbf781328cfd77e1d9fea86e2f58d3a0
1424 getColL8 :: GHC.Types.Int
1425 {- HasNoCafRefs, Strictness: m, Unfolding: (GHC.Types.I# 451#) -}
1426ac6cdea8a10db215e86741010968aa95
1427 getColL9 :: [GHC.Types.Char]
1428 {- Unfolding: (GHC.CString.unpackCString# Main.getColL10) -}
1429b2e16ce0be6dfbeea7c4f1ecb6d7439d
1430 getColL_go :: [GHC.Types.Char] -> [GHC.Types.Char]
1431 {- Arity: 1, Strictness: <S,1*U> -}
1432bad58c8bb42255af4a1eef18a97a672a
1433 getDiagL ::
1434 (GHC.Types.Int, GHC.Types.Int) -> Data.Matrix.Matrix a -> [a]
1435 {- Arity: 2,
1436 Strictness: <S(S(S)L),1*U(1*U(U),U(U))><L,U(U,U,U,U,U,U(U,A,U))>,
1437 Inline: [2],
1438 Unfolding: InlineRule (2, True, False)
1439 (\ @ a
1440 (w1 :: (GHC.Types.Int, GHC.Types.Int))
1441 (w2 :: Data.Matrix.Matrix a) ->
1442 case w1 of ww { (,) ww1 ww2 ->
1443 case ww1 of ww3 { GHC.Types.I# ww4 ->
1444 Main.$wgetDiagL @ a ww4 ww2 w2 } }) -}
1445b3250ecc7862688bbb8836fe2305b560
1446 getRowColDiag ::
1447 (GHC.Types.Int, GHC.Types.Int)
1448 -> Data.Matrix.Matrix a -> [((GHC.Types.Int, GHC.Types.Int), a)]
1449 {- Arity: 2,
1450 Strictness: <S,1*U(U(U),U(U))><S(SSSSSL),1*U(U,U,U,U,U,U(U,A,U))>,
1451 Inline: [2],
1452 Unfolding: InlineRule (2, True, False)
1453 (\ @ a
1454 (w1 :: (GHC.Types.Int, GHC.Types.Int))
1455 (w2 :: Data.Matrix.Matrix a) ->
1456 case w1 of ww { (,) ww1 ww2 ->
1457 case w2 of ww3 { Data.Matrix.M ww4 ww5 ww6 ww7 ww8 ww9 ->
1458 Main.$wgetRowColDiag @ a ww1 ww2 ww4 ww5 ww6 ww7 ww8 ww9 } }) -}
145989c54d6735deee0f2e6f5893b7bb62b3
1460 getRowL :: GHC.Types.Int -> Data.Matrix.Matrix b -> [b]
1461 {- Arity: 2, Strictness: <L,U(U)><L,U(U,U,U,U,U,U(U,A,U))>,
1462 Unfolding: (\ @ b
1463 (r :: GHC.Types.Int)
1464 (b1 :: Data.Matrix.Matrix b) ->
1465 letrec {
1466 go1 :: GHC.Prim.Int# -> [b] {- Arity: 1, Strictness: <L,U> -}
1467 = \ (x :: GHC.Prim.Int#) ->
1468 GHC.Types.:
1469 @ b
1470 (case b1 of wild { Data.Matrix.M dt dt1 dt2 dt3 dt4 ds ->
1471 case r of wild1 { GHC.Types.I# x1 ->
1472 let {
1473 $j :: b <join 0> {- Strictness: x -}
1474 = GHC.Err.error
1475 @ 'GHC.Types.LiftedRep
1476 @ b
1477 Main.getColL3
1478 `cast`
1479 (Sym (GHC.Classes.N:IP[0]
1480 <"callStack">_N <GHC.Stack.Types.CallStack>_N))
1481 (GHC.CString.unpackAppendCString#
1482 Main.getColL2
1483 (let {
1484 z :: [GHC.Types.Char]
1485 = GHC.CString.unpackAppendCString#
1486 Main.getColL1
1487 (case Data.Matrix.$wsizeStr
1488 dt
1489 (GHC.Types.I# dt1) of ww2 { (#,#) ww3 ww4 ->
1490 Main.getColL_go (GHC.Types.: @ GHC.Types.Char ww3 ww4) })
1491 } in
1492 letrec {
1493 go2 :: [GHC.Types.Char] -> [GHC.Types.Char]
1494 {- Arity: 1, Strictness: <S,1*U> -}
1495 = \ (ds1 :: [GHC.Types.Char]) ->
1496 case ds1 of wild2 {
1497 [] -> z : y ys -> GHC.Types.: @ GHC.Types.Char y (go2 ys) }
1498 } in
1499 go2
1500 (GHC.Types.:
1501 @ GHC.Types.Char
1502 GHC.Show.$fShow(,)4
1503 (case GHC.Show.$wshowSignedInt
1504 0#
1505 x1
1506 (GHC.Types.:
1507 @ GHC.Types.Char
1508 GHC.Show.showList__1
1509 (GHC.Show.$fShow(,)_$sgo1
1510 Main.getColL17
1511 (\ (w2 :: GHC.Base.String)[OneShot] ->
1512 case GHC.Show.$wshowSignedInt
1513 0#
1514 x
1515 w2 of ww4 { (#,#) ww5 ww6 ->
1516 GHC.Types.: @ GHC.Types.Char ww5 ww6 })
1517 (GHC.Types.[]
1518 @ GHC.Show.ShowS))) of ww4 { (#,#) ww5 ww6 ->
1519 GHC.Types.: @ GHC.Types.Char ww5 ww6 }))))
1520 } in
1521 case GHC.Prim.># x1 dt of lwild {
1522 DEFAULT
1523 -> case GHC.Prim.># x dt1 of lwild1 {
1524 DEFAULT
1525 -> case GHC.Prim.<# x1 1# of lwild2 {
1526 DEFAULT
1527 -> case GHC.Prim.<# x 1# of lwild3 {
1528 DEFAULT
1529 -> case ds of wild3 { Data.Vector.Vector dt5 dt6 dt7 ->
1530 case GHC.Prim.indexArray#
1531 @ b
1532 dt7
1533 (GHC.Prim.-#
1534 (GHC.Prim.+#
1535 dt5
1536 (GHC.Prim.+#
1537 (GHC.Prim.*#
1538 (GHC.Prim.-# (GHC.Prim.+# x1 dt2) 1#)
1539 dt4)
1540 (GHC.Prim.+# x dt3)))
1541 1#) of ds2 { Unit# ipv ->
1542 ipv } }
1543 1# -> $j }
1544 1# -> $j }
1545 1# -> $j }
1546 1# -> $j } } })
1547 (case x of wild {
1548 DEFAULT -> go1 (GHC.Prim.+# wild 1#) 8# -> GHC.Types.[] @ b })
1549 } in
1550 go1 1#) -}
15512a4c80aa03a4f7ee0eee9342de9b7e08
1552 initBoard :: Data.Matrix.Matrix Main.Square
1553 {- Strictness: m,
1554 Unfolding: (Data.Matrix.M
1555 @ Main.Square
1556 8#
1557 8#
1558 0#
1559 0#
1560 8#
1561 Main.initBoard1) -}
15622e11b49545df662a0298b6b61ce33edc
1563 initBoard1 :: Data.Vector.Vector Main.Square
1564 {- Unfolding: (case GHC.Magic.runRW#
1565 @ ('GHC.Types.TupleRep
1566 '[ 'GHC.Types.TupleRep '[], 'GHC.Types.LiftedRep])
1567 @ (# GHC.Prim.State# GHC.Prim.RealWorld,
1568 Data.Vector.Vector Main.Square #)
1569 Main.initBoard2 of ds1 { (#,#) ipv1 ipv2 ->
1570 ipv2 }) -}
15719ac58488e11448bdb0825964d3026604
1572 initBoard2 ::
1573 GHC.Prim.State# GHC.Prim.RealWorld
1574 -> (# GHC.Prim.State# GHC.Prim.RealWorld,
1575 Data.Vector.Vector Main.Square #)
1576 {- Arity: 1, Strictness: <S,U>,
1577 Unfolding: (\ (s1 :: GHC.Prim.State#
1578 GHC.Prim.RealWorld)[OneShot] ->
1579 case GHC.Prim.newArray#
1580 @ Main.Square
1581 @ (Control.Monad.Primitive.PrimState
1582 (GHC.ST.ST GHC.Prim.RealWorld))
1583 64#
1584 (Data.Vector.Mutable.uninitialised @ Main.Square)
1585 s1
1586 `cast`
1587 (GHC.Prim.State#
1588 (Sym (Control.Monad.Primitive.D:R:PrimStateST[0]
1589 (Nth:0
1590 (Nth:2
1591 (<GHC.Prim.State# GHC.Prim.RealWorld>_R
1592 ->_R ((#,#)
1593 <'GHC.Types.TupleRep '[]>_R
1594 <'GHC.Types.LiftedRep>_R
1595 <GHC.Prim.State# GHC.Prim.RealWorld>_R
1596 (Sub (Sym (Data.Vector.D:R:MutableVector[0])) <GHC.Prim.RealWorld>_N <Main.Square>_N))_R))))))_R of ds1 { (#,#) ipv ipv1 ->
1597 let {
1598 exit :: GHC.Prim.State# GHC.Prim.RealWorld
1599 -> (# GHC.Prim.State# GHC.Prim.RealWorld,
1600 Data.Vector.Vector Main.Square #)
1601 <join 1> {- Arity: 1, Strictness: <S,U> -}
1602 = \ (w1 :: GHC.Prim.State# GHC.Prim.RealWorld)[OneShot] ->
1603 let {
1604 exit1 :: GHC.Prim.State# GHC.Prim.RealWorld
1605 -> (# GHC.Prim.State# GHC.Prim.RealWorld,
1606 Data.Vector.Vector Main.Square #)
1607 <join 1> {- Arity: 1, Strictness: <S,U> -}
1608 = \ (w2 :: GHC.Prim.State# GHC.Prim.RealWorld)[OneShot] ->
1609 case GHC.Prim.writeArray#
1610 @ (Control.Monad.Primitive.PrimState
1611 (GHC.ST.ST GHC.Prim.RealWorld))
1612 @ Main.Square
1613 ipv1
1614 63#
1615 Main.O
1616 w2
1617 `cast`
1618 (GHC.Prim.State#
1619 (Sym (Control.Monad.Primitive.D:R:PrimStateST[0]
1620 <GHC.Prim.RealWorld>_N)))_R of s'# { DEFAULT ->
1621 case GHC.Prim.unsafeFreezeArray#
1622 @ (Control.Monad.Primitive.PrimState
1623 (GHC.ST.ST GHC.Prim.RealWorld))
1624 @ Main.Square
1625 ipv1
1626 s'# of ds2 { (#,#) ipv2 ipv3 ->
1627 (# ipv2
1628 `cast`
1629 (GHC.Prim.State#
1630 (Control.Monad.Primitive.D:R:PrimStateST[0]
1631 <GHC.Prim.RealWorld>_N))_R,
1632 Data.Vector.Vector @ Main.Square 0# 64# ipv3 #) } }
1633 } in
1634 letrec {
1635 $wgo3 :: GHC.Prim.Int#
1636 -> GHC.Prim.State# GHC.Prim.RealWorld
1637 -> (# GHC.Prim.State# GHC.Prim.RealWorld,
1638 Data.Vector.Vector Main.Square #)
1639 <join 2> {- Arity: 2, Strictness: <S,1*U><S,U>, Inline: [2] -}
1640 = \ (ww :: GHC.Prim.Int#)
1641 (w2 :: GHC.Prim.State# GHC.Prim.RealWorld) ->
1642 case ww of wild {
1643 DEFAULT
1644 -> case GHC.Prim.writeArray#
1645 @ (Control.Monad.Primitive.PrimState
1646 (GHC.ST.ST GHC.Prim.RealWorld))
1647 @ Main.Square
1648 ipv1
1649 (GHC.Prim.+# 55# wild)
1650 Main.O
1651 w2
1652 `cast`
1653 (GHC.Prim.State#
1654 (Sym (Control.Monad.Primitive.D:R:PrimStateST[0]
1655 <GHC.Prim.RealWorld>_N)))_R of s'# { DEFAULT ->
1656 $wgo3
1657 (GHC.Prim.+# wild 1#)
1658 s'#
1659 `cast`
1660 (GHC.Prim.State#
1661 (Control.Monad.Primitive.D:R:PrimStateST[0]
1662 <GHC.Prim.RealWorld>_N))_R }
1663 8# -> exit1 w2 }
1664 } in
1665 $wgo3 1# w1
1666 } in
1667 letrec {
1668 $wgo3 :: GHC.Prim.Int#
1669 -> GHC.Prim.State# GHC.Prim.RealWorld
1670 -> (# GHC.Prim.State# GHC.Prim.RealWorld,
1671 Data.Vector.Vector Main.Square #)
1672 <join 2> {- Arity: 2, Strictness: <S,1*U><S,U>, Inline: [2] -}
1673 = \ (ww :: GHC.Prim.Int#)
1674 (w1 :: GHC.Prim.State# GHC.Prim.RealWorld) ->
1675 case ww of wild {
1676 DEFAULT
1677 -> let {
1678 exit1 :: GHC.Prim.State# GHC.Prim.RealWorld
1679 -> (# GHC.Prim.State# GHC.Prim.RealWorld,
1680 Data.Vector.Vector Main.Square #)
1681 <join 1> {- Arity: 1, Strictness: <S,U> -}
1682 = \ (w2 :: GHC.Prim.State# GHC.Prim.RealWorld)[OneShot] ->
1683 case GHC.Prim.writeArray#
1684 @ (Control.Monad.Primitive.PrimState
1685 (GHC.ST.ST GHC.Prim.RealWorld))
1686 @ Main.Square
1687 ipv1
1688 (GHC.Prim.+# -1# (GHC.Prim.*# 8# wild))
1689 Main.O
1690 w2
1691 `cast`
1692 (GHC.Prim.State#
1693 (Sym (Control.Monad.Primitive.D:R:PrimStateST[0]
1694 <GHC.Prim.RealWorld>_N)))_R of s'# { DEFAULT ->
1695 $wgo3
1696 (GHC.Prim.+# wild 1#)
1697 s'#
1698 `cast`
1699 (GHC.Prim.State#
1700 (Control.Monad.Primitive.D:R:PrimStateST[0]
1701 <GHC.Prim.RealWorld>_N))_R }
1702 } in
1703 letrec {
1704 $wgo1 :: GHC.Prim.Int#
1705 -> GHC.Prim.State# GHC.Prim.RealWorld
1706 -> (# GHC.Prim.State# GHC.Prim.RealWorld,
1707 Data.Vector.Vector Main.Square #)
1708 <join 2> {- Arity: 2, Strictness: <S,1*U><S,U>, Inline: [2] -}
1709 = \ (ww1 :: GHC.Prim.Int#)
1710 (w2 :: GHC.Prim.State# GHC.Prim.RealWorld) ->
1711 case ww1 of wild1 {
1712 DEFAULT
1713 -> case GHC.Prim.writeArray#
1714 @ (Control.Monad.Primitive.PrimState
1715 (GHC.ST.ST GHC.Prim.RealWorld))
1716 @ Main.Square
1717 ipv1
1718 (GHC.Prim.+#
1719 -9#
1720 (GHC.Prim.+# wild1 (GHC.Prim.*# 8# wild)))
1721 Main.O
1722 w2
1723 `cast`
1724 (GHC.Prim.State#
1725 (Sym (Control.Monad.Primitive.D:R:PrimStateST[0]
1726 <GHC.Prim.RealWorld>_N)))_R of s'# { DEFAULT ->
1727 $wgo1
1728 (GHC.Prim.+# wild1 1#)
1729 s'#
1730 `cast`
1731 (GHC.Prim.State#
1732 (Control.Monad.Primitive.D:R:PrimStateST[0]
1733 <GHC.Prim.RealWorld>_N))_R }
1734 8# -> exit1 w2 }
1735 } in
1736 $wgo1 1# w1
1737 8# -> exit w1 }
1738 } in
1739 $wgo3
1740 1#
1741 ipv
1742 `cast`
1743 (GHC.Prim.State#
1744 (Control.Monad.Primitive.D:R:PrimStateST[0]
1745 <GHC.Prim.RealWorld>_N))_R }) -}
1746419b12158f8179bd4e20ff85d2021536
1747 isWinnable ::
1748 GHC.Types.Int -> Data.Matrix.Matrix Main.Square -> GHC.Types.Bool
1749 {- Arity: 2, Strictness: <S(S),1*U(U)><L,U(U,U,U,U,U,U(U,A,U))>,
1750 Inline: [2],
1751 Unfolding: InlineRule (2, True, False)
1752 (\ (w1 :: GHC.Types.Int) (w2 :: Data.Matrix.Matrix Main.Square) ->
1753 case w1 of ww { GHC.Types.I# ww1 -> Main.$wisWinnable ww1 w2 }) -}
1754db1e2e2978dca671b96a5fb06e38a355
1755 isWinnable' ::
1756 p -> Data.Matrix.Matrix Main.Square -> [GHC.Types.Char]
1757 {- Arity: 2, Strictness: <L,A><L,U(U,U,U,U,U,U(U,A,U))>,
1758 Inline: [2],
1759 Unfolding: InlineRule (2, True, True)
1760 (\ @ p (w1 :: p) (w2 :: Data.Matrix.Matrix Main.Square) ->
1761 Main.$wisWinnable' @ p w2) -}
1762fe5821aa57b843ac278ee5301d522efa
1763 isWinnable'1 :: GHC.Prim.Addr#
1764 {- HasNoCafRefs, Unfolding: (" | cs: "#) -}
176557dbea7ccb37666dfb68fcfa3dff9762
1766 isWinnable'2 :: GHC.Prim.Addr#
1767 {- HasNoCafRefs, Unfolding: ("rs: "#) -}
176871761c5fe498240bc954dabe79b454e6
1769 isWinnable1 :: [GHC.Types.Int]
1770 {- Unfolding: (GHC.Enum.eftInt 1# 8#) -}
1771467cbfe928e10131bc536f2ce6cf6555
1772 lo1 :: GHC.Integer.Type.Integer
1773 {- HasNoCafRefs, Unfolding: (8) -}
17740443aef89f06e494b8dfadf33d9b611e
1775 lo2 :: GHC.Integer.Type.Integer
1776 {- HasNoCafRefs, Unfolding: (0) -}
17770adafc7a5420e905b14b79259f36d2e1
1778 lo8 :: [GHC.Integer.Type.Integer]
1779 {- Unfolding: (GHC.Enum.enumDeltaToInteger1 Main.lo2 Main.lo1) -}
1780ffd93c9b62998844891c6b51af4852f6
1781 main :: GHC.Types.IO ()
1782 {- Arity: 1,
1783 Unfolding: (GHC.IO.Handle.Text.hPutStr'
1784 GHC.IO.Handle.FD.stdout
1785 Main.main1
1786 GHC.Types.True) -}
1787b44f955f71899d698edc98e351205550
1788 main1 :: [GHC.Types.Char]
1789 {- Unfolding: (GHC.CString.unpackCString# Main.main2) -}
179053f8d0c8d47323120ec6d4f5391ba8c2
1791 main2 :: GHC.Prim.Addr#
1792 {- HasNoCafRefs, Unfolding: ("Hi"#) -}
17932c40f682ff1df8a53498b11b24c5d251
1794 main3 ::
1795 GHC.Prim.State# GHC.Prim.RealWorld
1796 -> (# GHC.Prim.State# GHC.Prim.RealWorld, () #)
1797 {- Arity: 1,
1798 Unfolding: (GHC.TopHandler.runMainIO1 @ () Main.main) -}
17992d937b3fb3901c9c5d6305d505827f2c
1800 mapDiag ::
1801 ((GHC.Types.Int, GHC.Types.Int) -> a -> a)
1802 -> (GHC.Types.Int, GHC.Types.Int)
1803 -> Data.Matrix.Matrix a
1804 -> Data.Matrix.Matrix a
1805 {- Arity: 3,
1806 Strictness: <L,C(C1(U))><L,1*U(1*U(U),U(U))><S(SSSSSL),1*U(U,U,U,U,U,U(U,A,U))>m,
1807 Inline: [2],
1808 Unfolding: InlineRule (3, True, False)
1809 (\ @ a
1810 (w1 :: (GHC.Types.Int, GHC.Types.Int) -> a -> a)
1811 (w2 :: (GHC.Types.Int, GHC.Types.Int))
1812 (w3 :: Data.Matrix.Matrix a) ->
1813 case w3 of ww { Data.Matrix.M ww1 ww2 ww3 ww4 ww5 ww6 ->
1814 case Main.$wmapDiag
1815 @ a
1816 w1
1817 w2
1818 ww1
1819 ww2
1820 ww3
1821 ww4
1822 ww5
1823 ww6 of ww7 { (#,,,,,#) ww8 ww9 ww10 ww11 ww12 ww13 ->
1824 Data.Matrix.M @ a ww8 ww9 ww10 ww11 ww12 ww13 } }) -}
1825a2bd0b58bc5bd047e61382be16fefa00
1826 mapQueensPath ::
1827 ((GHC.Types.Int, GHC.Types.Int) -> a -> a)
1828 -> (GHC.Types.Int, GHC.Types.Int)
1829 -> Data.Matrix.Matrix a
1830 -> Data.Matrix.Matrix a
1831 {- Arity: 3,
1832 Strictness: <L,C(C1(U))><S,1*U(U(U),U(U))><S(SSSSSL),1*U(U,U,U,U,U,U(U,A,U))>m,
1833 Unfolding: InlineRule (0, True, True) Main.mapRowColDiag -}
1834dde1889dbbf5fb38f0e445cb95f5a9de
1835 mapRowColDiag ::
1836 ((GHC.Types.Int, GHC.Types.Int) -> a -> a)
1837 -> (GHC.Types.Int, GHC.Types.Int)
1838 -> Data.Matrix.Matrix a
1839 -> Data.Matrix.Matrix a
1840 {- Arity: 3,
1841 Strictness: <L,C(C1(U))><S,1*U(U(U),U(U))><S(SSSSSL),1*U(U,U,U,U,U,U(U,A,U))>m,
1842 Inline: [2],
1843 Unfolding: InlineRule (3, True, False)
1844 (\ @ a
1845 (w1 :: (GHC.Types.Int, GHC.Types.Int) -> a -> a)
1846 (w2 :: (GHC.Types.Int, GHC.Types.Int))
1847 (w3 :: Data.Matrix.Matrix a) ->
1848 case w2 of ww { (,) ww1 ww2 ->
1849 case w3 of ww3 { Data.Matrix.M ww4 ww5 ww6 ww7 ww8 ww9 ->
1850 case Main.$wmapRowColDiag
1851 @ a
1852 w1
1853 ww1
1854 ww2
1855 ww4
1856 ww5
1857 ww6
1858 ww7
1859 ww8
1860 ww9 of ww10 { (#,,,,,#) ww11 ww12 ww13 ww14 ww15 ww16 ->
1861 Data.Matrix.M @ a ww11 ww12 ww13 ww14 ww15 ww16 } } }) -}
18623943af003e5304a56a545bd865552127
1863 markX ::
1864 (GHC.Types.Int, GHC.Types.Int)
1865 -> Data.Matrix.Matrix Main.Square -> Data.Matrix.Matrix Main.Square
1866 {- Arity: 2,
1867 Strictness: <L,1*U(1*U(U),1*U(U))><S(SSSSSL),1*U(U,U,U,U,U,1*U(U,U,U))>m,
1868 Inline: [2],
1869 Unfolding: InlineRule (2, True, False)
1870 (\ (w1 :: (GHC.Types.Int, GHC.Types.Int))
1871 (w2 :: Data.Matrix.Matrix Main.Square) ->
1872 case w2 of ww { Data.Matrix.M ww1 ww2 ww3 ww4 ww5 ww6 ->
1873 case Main.$wmarkX
1874 w1
1875 ww1
1876 ww2
1877 ww3
1878 ww4
1879 ww5
1880 ww6 of ww7 { (#,,,,,#) ww8 ww9 ww10 ww11 ww12 ww13 ->
1881 Data.Matrix.M @ Main.Square ww8 ww9 ww10 ww11 ww12 ww13 } }) -}
1882ccc5982bcd77bdad61f876f8d47c5d65
1883 markX1 :: GHC.Prim.Int# -> GHC.Prim.Int# -> GHC.ST.ST s ()
1884 {- Arity: 2, Strictness: <B,U><B,U>x -}
1885fbac9f9d7dbb4ee97cbb457aa87ce63d
1886 markX2 ::
1887 GHC.Prim.Int#
1888 -> GHC.ST.ST
1889 GHC.Prim.RealWorld
1890 (Data.Vector.Generic.Base.Mutable
1891 Data.Vector.Vector
1892 (Control.Monad.Primitive.PrimState (GHC.ST.ST GHC.Prim.RealWorld))
1893 Main.Square)
1894 {- Arity: 1, Strictness: <B,U>x -}
18956f1bb09ac67d2a25f7bab55f41ed00c2
1896 nextAvail ::
1897 Data.Matrix.Matrix Main.Square -> (GHC.Types.Int, GHC.Types.Int)
1898 {- Arity: 1, Strictness: <S(SSSSSL),1*U(U,U,U,U,U,U(U,A,U))>m,
1899 Inline: [2],
1900 Unfolding: InlineRule (1, True, False)
1901 (\ (w1 :: Data.Matrix.Matrix Main.Square) ->
1902 case w1 of ww { Data.Matrix.M ww1 ww2 ww3 ww4 ww5 ww6 ->
1903 Main.$wnextAvail ww1 ww2 ww3 ww4 ww5 ww6 }) -}
190490afd4aefbf3357e19db3aabe3af6a43
1905 nextAvail1 ::
1906 GHC.Prim.Int#
1907 -> GHC.Types.Int -> GHC.Prim.Int# -> GHC.Prim.Int# -> Main.Square
1908 {- Arity: 4, Strictness: <B,U><B,1*U(U)><B,U><B,U>x -}
1909a26d623557216e1e594771f61834fea6
1910 nextAvail_$sscanBoard ::
1911 Main.Square
1912 -> Data.Matrix.Matrix Main.Square
1913 -> [(GHC.Types.Int, GHC.Types.Int)]
1914 {- Arity: 2, Strictness: <L,U><L,U(U,U,U,U,U,U(U,A,U))>,
1915 Unfolding: (\ (s1 :: Main.Square)
1916 (b :: Data.Matrix.Matrix Main.Square) ->
1917 letrec {
1918 go1 :: [(GHC.Types.Int, GHC.Types.Int)]
1919 -> [(GHC.Types.Int, GHC.Types.Int)]
1920 {- Arity: 1, Strictness: <S,1*U> -}
1921 = \ (ds :: [(GHC.Types.Int, GHC.Types.Int)]) ->
1922 case ds of wild {
1923 [] -> GHC.Types.[] @ (GHC.Types.Int, GHC.Types.Int)
1924 : y ys
1925 -> case y of wild1 { (,) i j ->
1926 case b of wild2 { Data.Matrix.M dt dt1 dt2 dt3 dt4 ds1 ->
1927 case i of wild3 { GHC.Types.I# x ->
1928 case GHC.Prim.># x dt of lwild {
1929 DEFAULT
1930 -> case j of wild4 { GHC.Types.I# x1 ->
1931 case GHC.Prim.># x1 dt1 of lwild1 {
1932 DEFAULT
1933 -> case GHC.Prim.<# x 1# of lwild2 {
1934 DEFAULT
1935 -> case GHC.Prim.<# x1 1# of lwild3 {
1936 DEFAULT
1937 -> case ds1 of wild5 { Data.Vector.Vector dt5 dt6 dt7 ->
1938 case GHC.Prim.indexArray#
1939 @ Main.Square
1940 dt7
1941 (GHC.Prim.-#
1942 (GHC.Prim.+#
1943 dt5
1944 (GHC.Prim.+#
1945 (GHC.Prim.*#
1946 (GHC.Prim.-#
1947 (GHC.Prim.+# x dt2)
1948 1#)
1949 dt4)
1950 (GHC.Prim.+# x1 dt3)))
1951 1#) of ds2 { Unit# ipv ->
1952 case ipv of wild6 {
1953 Main.X
1954 -> case s1 of wild7 {
1955 DEFAULT -> go1 ys
1956 Main.X
1957 -> GHC.Types.:
1958 @ (GHC.Types.Int, GHC.Types.Int)
1959 wild1
1960 (go1 ys) }
1961 Main.Qu
1962 -> case s1 of wild7 {
1963 DEFAULT -> go1 ys
1964 Main.Qu
1965 -> GHC.Types.:
1966 @ (GHC.Types.Int, GHC.Types.Int)
1967 wild1
1968 (go1 ys) }
1969 Main.O
1970 -> case s1 of wild7 {
1971 DEFAULT -> go1 ys
1972 Main.O
1973 -> GHC.Types.:
1974 @ (GHC.Types.Int, GHC.Types.Int)
1975 wild1
1976 (go1 ys) }
1977 Main.T
1978 -> case s1 of wild7 {
1979 DEFAULT -> go1 ys
1980 Main.T
1981 -> GHC.Types.:
1982 @ (GHC.Types.Int, GHC.Types.Int)
1983 wild1
1984 (go1 ys) } } } }
1985 1#
1986 -> case Main.nextAvail1 x wild4 dt dt1
1987 ret_ty [(GHC.Types.Int, GHC.Types.Int)]
1988 of {} }
1989 1#
1990 -> case Main.nextAvail1 x wild4 dt dt1
1991 ret_ty [(GHC.Types.Int, GHC.Types.Int)]
1992 of {} }
1993 1#
1994 -> case Main.nextAvail1 x wild4 dt dt1
1995 ret_ty [(GHC.Types.Int, GHC.Types.Int)]
1996 of {} } }
1997 1#
1998 -> case Main.nextAvail1 x j dt dt1
1999 ret_ty [(GHC.Types.Int, GHC.Types.Int)]
2000 of {} } } } } }
2001 } in
2002 go1 Main.allPositions) -}
20039b22cd0f7cfb9cd8b86e53ed152db98f
2004 nextOpen :: p -> a
2005 {- Arity: 1, Strictness: <B,A>x,
2006 Unfolding: InlineRule (1, True, True)
2007 (\ @ p @ a (board :: p) ->
2008 GHC.Err.undefined
2009 @ 'GHC.Types.LiftedRep
2010 @ a
2011 Main.nextOpen1
2012 `cast`
2013 (Sym (GHC.Classes.N:IP[0]
2014 <"callStack">_N <GHC.Stack.Types.CallStack>_N))) -}
2015450959e15bf14abeeae70c90d6596591
2016 nextOpen1 :: GHC.Stack.Types.CallStack
2017 {- Strictness: m2,
2018 Unfolding: (GHC.Stack.Types.PushCallStack
2019 Main.nextOpen10
2020 Main.nextOpen2
2021 GHC.Stack.Types.EmptyCallStack) -}
20225492e46593435c9a8973ddd52706b901
2023 nextOpen10 :: [GHC.Types.Char]
2024 {- Unfolding: (GHC.CString.unpackCString# Main.nextOpen11) -}
202534b8814fdedc12dbe175ff398d732cc2
2026 nextOpen11 :: GHC.Prim.Addr#
2027 {- HasNoCafRefs, Unfolding: ("undefined"#) -}
2028a81645774aa6aa0b43d03ce34ef4c86a
2029 nextOpen2 :: GHC.Stack.Types.SrcLoc
2030 {- Strictness: m,
2031 Unfolding: (GHC.Stack.Types.SrcLoc
2032 Main.nextOpen9
2033 Main.nextOpen8
2034 Main.nextOpen6
2035 Main.nextOpen5
2036 Main.nextOpen4
2037 Main.nextOpen5
2038 Main.nextOpen3) -}
203937396b724a9489f0796e02e1242a57cc
2040 nextOpen3 :: GHC.Types.Int
2041 {- HasNoCafRefs, Strictness: m, Unfolding: (GHC.Types.I# 27#) -}
20425039b2582c970c303d6ee00f1c72dc6f
2043 nextOpen4 :: GHC.Types.Int
2044 {- HasNoCafRefs, Strictness: m, Unfolding: (GHC.Types.I# 18#) -}
2045d043f6099eb02d490a19ed2603a147cd
2046 nextOpen5 :: GHC.Types.Int
2047 {- HasNoCafRefs, Strictness: m, Unfolding: (GHC.Types.I# 342#) -}
20488bc53bd5eeee20b8c206a89fe19f2abc
2049 nextOpen6 :: [GHC.Types.Char]
2050 {- Unfolding: (GHC.CString.unpackCString# Main.nextOpen7) -}
205128b6eb018de3ac0765c6732596651e21
2052 nextOpen7 :: GHC.Prim.Addr#
2053 {- HasNoCafRefs, Unfolding: ("src/Main.hs"#) -}
20545dd9ebfbcdd27071fb3e5331918a8ed9
2055 nextOpen8 :: [GHC.Types.Char]
2056 {- Unfolding: (GHC.CString.unpackCString# Main.$trModule2) -}
20573ec743b2d53b5b2446ef227872aec674
2058 nextOpen9 :: [GHC.Types.Char]
2059 {- Unfolding: (GHC.CString.unpackCString# Main.$trModule4) -}
2060b1f6f256d4e82d1580367898de062da9
2061 onBoard :: t1 -> (t1 -> t2) -> t2
2062 {- Arity: 2, HasNoCafRefs, Strictness: <L,U><C(S),1*C1(U)>,
2063 Unfolding: InlineRule (2, True, True)
2064 (\ @ t @ t1 (b :: t) (f :: t -> t1) -> f b) -}
206517b16fcc71d1f9f19009053f733f93b0
2066 openPositions ::
2067 Data.Matrix.Matrix Main.Square -> [(GHC.Types.Int, GHC.Types.Int)]
2068 {- Arity: 1, Strictness: <L,U(U,U,U,U,U,U(U,A,U))>,
2069 Unfolding: InlineRule (1, True, False)
2070 (\ (b :: Data.Matrix.Matrix Main.Square) ->
2071 Main.nextAvail_$sscanBoard Main.O b) -}
20722f3c3f4fd9297ce38b2338795b8625fa
2073 ops ::
2074 [(GHC.Integer.Type.Integer -> GHC.Integer.Type.Integer,
2075 GHC.Integer.Type.Integer -> GHC.Integer.Type.Integer)]
2076 {- Strictness: m2,
2077 Unfolding: (GHC.Types.:
2078 @ (GHC.Integer.Type.Integer -> GHC.Integer.Type.Integer,
2079 GHC.Integer.Type.Integer -> GHC.Integer.Type.Integer)
2080 Main.ops8
2081 Main.ops1) -}
2082914d1c5f1d08a2df33b0758b8b1cbe4f
2083 ops1 ::
2084 [(GHC.Integer.Type.Integer -> GHC.Integer.Type.Integer,
2085 GHC.Integer.Type.Integer -> GHC.Integer.Type.Integer)]
2086 {- Strictness: m2,
2087 Unfolding: (GHC.Types.:
2088 @ (GHC.Integer.Type.Integer -> GHC.Integer.Type.Integer,
2089 GHC.Integer.Type.Integer -> GHC.Integer.Type.Integer)
2090 Main.ops7
2091 Main.ops2) -}
2092c483f6d1360d80e682071a7fada76a2d
2093 ops2 ::
2094 [(GHC.Integer.Type.Integer -> GHC.Integer.Type.Integer,
2095 GHC.Integer.Type.Integer -> GHC.Integer.Type.Integer)]
2096 {- Strictness: m2,
2097 Unfolding: (GHC.Types.:
2098 @ (GHC.Integer.Type.Integer -> GHC.Integer.Type.Integer,
2099 GHC.Integer.Type.Integer -> GHC.Integer.Type.Integer)
2100 Main.ops6
2101 Main.ops3) -}
2102e2bf2566ee0d78e121b68669d2a45b5a
2103 ops3 ::
2104 [(GHC.Integer.Type.Integer -> GHC.Integer.Type.Integer,
2105 GHC.Integer.Type.Integer -> GHC.Integer.Type.Integer)]
2106 {- Strictness: m2,
2107 Unfolding: (GHC.Types.:
2108 @ (GHC.Integer.Type.Integer -> GHC.Integer.Type.Integer,
2109 GHC.Integer.Type.Integer -> GHC.Integer.Type.Integer)
2110 Main.ops4
2111 (GHC.Types.[]
2112 @ (GHC.Integer.Type.Integer -> GHC.Integer.Type.Integer,
2113 GHC.Integer.Type.Integer -> GHC.Integer.Type.Integer))) -}
21144fc14e12c3c545bccf354dfd328363ef
2115 ops4 ::
2116 (GHC.Integer.Type.Integer -> GHC.Integer.Type.Integer,
2117 GHC.Integer.Type.Integer -> GHC.Integer.Type.Integer)
2118 {- Strictness: m, Unfolding: ((Main.ops_b, Main.ops_b)) -}
2119af67511cc9af72bbbf64830e0e5f2972
2120 ops5 :: GHC.Integer.Type.Integer
2121 {- HasNoCafRefs, Unfolding: (1) -}
21224d05bf6b8d38e4924dbd1cd6fe91b988
2123 ops6 ::
2124 (GHC.Integer.Type.Integer -> GHC.Integer.Type.Integer,
2125 GHC.Integer.Type.Integer -> GHC.Integer.Type.Integer)
2126 {- Strictness: m, Unfolding: ((Main.ops_b, Main.ops_a)) -}
2127c8c7d7c9f7f07dc27b1d7488f2d275c4
2128 ops7 ::
2129 (GHC.Integer.Type.Integer -> GHC.Integer.Type.Integer,
2130 GHC.Integer.Type.Integer -> GHC.Integer.Type.Integer)
2131 {- Strictness: m, Unfolding: ((Main.ops_a, Main.ops_b)) -}
2132659cc3ca049e6155e4c40a7665798164
2133 ops8 ::
2134 (GHC.Integer.Type.Integer -> GHC.Integer.Type.Integer,
2135 GHC.Integer.Type.Integer -> GHC.Integer.Type.Integer)
2136 {- Strictness: m, Unfolding: ((Main.ops_a, Main.ops_a)) -}
2137230c5a60ddf52a851259b0f5fb0b5a02
2138 ops_a :: GHC.Integer.Type.Integer -> GHC.Integer.Type.Integer
2139 {- Arity: 1, Strictness: <S,1*U>,
2140 Unfolding: InlineRule (1, True, False)
2141 (\ (ds :: GHC.Integer.Type.Integer) ->
2142 GHC.Integer.Type.plusInteger ds Main.ops5) -}
21430977965361a29e006d3b014e5d47953c
2144 ops_b :: GHC.Integer.Type.Integer -> GHC.Integer.Type.Integer
2145 {- Arity: 1, Unfolding: (Main.$ssubtract1 Main.ops5) -}
2146fa63260e1ced6c325a6fea254285a86e
2147 placeQueen ::
2148 (GHC.Types.Int, GHC.Types.Int)
2149 -> Data.Matrix.Matrix Main.Square -> Data.Matrix.Matrix Main.Square
2150 {- Arity: 2,
2151 Strictness: <S,1*U(U(U),U(U))><S(SSSSSL),1*U(U,U,U,U,U,U(U,A,U))>m,
2152 Inline: [2],
2153 Unfolding: InlineRule (2, True, False)
2154 (\ (w1 :: (GHC.Types.Int, GHC.Types.Int))
2155 (w2 :: Data.Matrix.Matrix Main.Square) ->
2156 case w1 of ww { (,) ww1 ww2 ->
2157 case w2 of ww3 { Data.Matrix.M ww4 ww5 ww6 ww7 ww8 ww9 ->
2158 case Main.$wplaceQueen
2159 ww1
2160 ww2
2161 ww4
2162 ww5
2163 ww6
2164 ww7
2165 ww8
2166 ww9 of ww10 { (#,,,,,#) ww11 ww12 ww13 ww14 ww15 ww16 ->
2167 Data.Matrix.M @ Main.Square ww11 ww12 ww13 ww14 ww15 ww16 } } }) -}
2168a1f12d5025f58ce56d4a5a7bc26dc092
2169 placeQueen' ::
2170 (GHC.Types.Int, GHC.Types.Int)
2171 -> Data.Matrix.Matrix Main.Square -> Data.Matrix.Matrix Main.Square
2172 {- Arity: 2,
2173 Strictness: <S,1*U(U(U),U(U))><S(SSSSSL),1*U(U,U,U,U,U,U(U,A,U))>m,
2174 Inline: [2],
2175 Unfolding: InlineRule (2, True, False)
2176 (\ (w1 :: (GHC.Types.Int, GHC.Types.Int))
2177 (w2 :: Data.Matrix.Matrix Main.Square) ->
2178 case w1 of ww { (,) ww1 ww2 ->
2179 case w2 of ww3 { Data.Matrix.M ww4 ww5 ww6 ww7 ww8 ww9 ->
2180 case Main.$wplaceQueen'
2181 ww1
2182 ww2
2183 ww4
2184 ww5
2185 ww6
2186 ww7
2187 ww8
2188 ww9 of ww10 { (#,,,,,#) ww11 ww12 ww13 ww14 ww15 ww16 ->
2189 Data.Matrix.M @ Main.Square ww11 ww12 ww13 ww14 ww15 ww16 } } }) -}
2190dc257c873b9f55af4a5cae0dd796842c
2191 placeQueen'_fX :: p1 -> p2 -> Main.Square
2192 {- Arity: 2, HasNoCafRefs, Strictness: <L,A><L,A>,
2193 Unfolding: InlineRule (2, True, True)
2194 (\ @ p @ p1 (ds :: p) (x :: p1) -> Main.X) -}
21955867a72be54a53ffdbc791900449f7cf
2196 placeQueen1 ::
2197 (GHC.Types.Int, GHC.Types.Int) -> Main.Square -> Main.Square
2198 {- Arity: 2, HasNoCafRefs, Strictness: <L,A><L,A>,
2199 Unfolding: InlineRule (2, True, True)
2200 (\ (ds :: (GHC.Types.Int, GHC.Types.Int)) (ds1 :: Main.Square) ->
2201 Main.X) -}
22026e29c0608e46d228d79be61c7b198415
2203 queenAllowed ::
2204 (GHC.Types.Int, GHC.Types.Int)
2205 -> Data.Matrix.Matrix Main.Square -> GHC.Types.Bool
2206 {- Arity: 2,
2207 Strictness: <S,1*U(U(U),U(U))><S(SSSSSL),1*U(U,U,U,U,U,U(U,A,U))>,
2208 Unfolding: InlineRule (0, True, True)
2209 Main.queenAllowed1
2210 `cast`
2211 (<(GHC.Types.Int, GHC.Types.Int)>_R
2212 ->_R <Data.Matrix.Matrix Main.Square>_R
2213 ->_R Data.Semigroup.Internal.N:All[0]) -}
221478aa727ec6070d1a0a93c445c121ee95
2215 queenAllowed1 ::
2216 (GHC.Types.Int, GHC.Types.Int)
2217 -> Data.Matrix.Matrix Main.Square -> Data.Semigroup.Internal.All
2218 {- Arity: 2,
2219 Strictness: <S,1*U(U(U),U(U))><S(SSSSSL),1*U(U,U,U,U,U,U(U,A,U))>,
2220 Unfolding: InlineRule (2, True, False)
2221 (\ (p :: (GHC.Types.Int, GHC.Types.Int))
2222 (b :: Data.Matrix.Matrix Main.Square) ->
2223 letrec {
2224 go1 :: [((GHC.Types.Int, GHC.Types.Int), Main.Square)]
2225 -> Data.Semigroup.Internal.All
2226 <join 1> {- Arity: 1 -}
2227 = \ (ds :: [((GHC.Types.Int, GHC.Types.Int), Main.Square)]) ->
2228 case ds of wild {
2229 []
2230 -> GHC.Types.True `cast` (Sym (Data.Semigroup.Internal.N:All[0]))
2231 : y ys
2232 -> case y of wild1 { (,) ds1 y1 ->
2233 case y1 of wild2 {
2234 DEFAULT
2235 -> GHC.Types.False `cast` (Sym (Data.Semigroup.Internal.N:All[0]))
2236 Main.O -> go1 ys } } }
2237 } in
2238 go1 (Main.getRowColDiag @ Main.Square p b)) -}
2239ac3e1db14fd14a5e30c664cab50d0fee
2240 s ::
2241 Data.Matrix.Matrix Main.Square -> [Data.Matrix.Matrix Main.Square]
2242 {- Arity: 1, Strictness: <L,U(U,U,U,U,U,U(U,A,U))>,
2243 Unfolding: (\ (b :: Data.Matrix.Matrix Main.Square) ->
2244 letrec {
2245 go1 :: [(GHC.Types.Int, GHC.Types.Int)]
2246 -> [Data.Matrix.Matrix Main.Square]
2247 {- Arity: 1, Strictness: <S,1*U> -}
2248 = \ (ds :: [(GHC.Types.Int, GHC.Types.Int)]) ->
2249 case ds of wild {
2250 [] -> GHC.Types.[] @ (Data.Matrix.Matrix Main.Square)
2251 : y ys
2252 -> case y of ww { (,) ww1 ww2 ->
2253 case b of ww3 { Data.Matrix.M ww4 ww5 ww6 ww7 ww8 ww9 ->
2254 let {
2255 exit :: [Data.Matrix.Matrix Main.Square] <join 0>
2256 = GHC.Types.:
2257 @ (Data.Matrix.Matrix Main.Square)
2258 (case Main.$wplaceQueen
2259 ww1
2260 ww2
2261 ww4
2262 ww5
2263 ww6
2264 ww7
2265 ww8
2266 ww9 of ww10 { (#,,,,,#) ww11 ww12 ww13 ww14 ww15 ww16 ->
2267 Data.Matrix.M @ Main.Square ww11 ww12 ww13 ww14 ww15 ww16 })
2268 (go1 ys)
2269 } in
2270 let {
2271 exit1 :: [Data.Matrix.Matrix Main.Square] <join 0> = go1 ys
2272 } in
2273 letrec {
2274 go2 :: [((GHC.Types.Int, GHC.Types.Int), Main.Square)]
2275 -> [Data.Matrix.Matrix Main.Square]
2276 <join 1> {- Arity: 1, Strictness: <S,1*U> -}
2277 = \ (ds1 :: [((GHC.Types.Int, GHC.Types.Int), Main.Square)]) ->
2278 case ds1 of wild1 {
2279 [] -> exit
2280 : y1 ys1
2281 -> case y1 of wild2 { (,) ds2 y2 ->
2282 case y2 of wild3 { DEFAULT -> exit1 Main.O -> go2 ys1 } } }
2283 } in
2284 go2
2285 (Main.$wgetRowColDiag
2286 @ Main.Square
2287 ww1
2288 ww2
2289 ww4
2290 ww5
2291 ww6
2292 ww7
2293 ww8
2294 ww9) } } }
2295 } in
2296 go1 (Main.nextAvail_$sscanBoard Main.O b)) -}
2297136bbc6ab363482125bcf62d8afaf976
2298 scanBoard ::
2299 GHC.Classes.Eq a =>
2300 a -> Data.Matrix.Matrix a -> [(GHC.Types.Int, GHC.Types.Int)]
2301 {- Arity: 3,
2302 Strictness: <L,U(C(C1(U)),A)><L,U><L,U(U,U,U,U,U,U(U,A,U))>,
2303 Unfolding: (\ @ a
2304 ($dEq :: GHC.Classes.Eq a)
2305 (s1 :: a)
2306 (b :: Data.Matrix.Matrix a) ->
2307 letrec {
2308 go1 :: [(GHC.Types.Int, GHC.Types.Int)]
2309 -> [(GHC.Types.Int, GHC.Types.Int)]
2310 {- Arity: 1, Strictness: <S,1*U> -}
2311 = \ (ds :: [(GHC.Types.Int, GHC.Types.Int)]) ->
2312 case ds of wild {
2313 [] -> GHC.Types.[] @ (GHC.Types.Int, GHC.Types.Int)
2314 : y ys
2315 -> case y of wild1 { (,) i j ->
2316 case GHC.Classes.==
2317 @ a
2318 $dEq
2319 (case b of wild2 { Data.Matrix.M dt dt1 dt2 dt3 dt4 ds1 ->
2320 case i of wild3 { GHC.Types.I# x ->
2321 let {
2322 $j :: a <join 0> {- Strictness: x -}
2323 = GHC.Err.error
2324 @ 'GHC.Types.LiftedRep
2325 @ a
2326 Main.getColL3
2327 `cast`
2328 (Sym (GHC.Classes.N:IP[0]
2329 <"callStack">_N <GHC.Stack.Types.CallStack>_N))
2330 (GHC.CString.unpackAppendCString#
2331 Main.getColL2
2332 (GHC.Base.++_$s++
2333 @ GHC.Types.Char
2334 (GHC.CString.unpackAppendCString#
2335 Main.getColL1
2336 (case Data.Matrix.$wsizeStr
2337 dt
2338 (GHC.Types.I#
2339 dt1) of ww2 { (#,#) ww3 ww4 ->
2340 GHC.Base.++_$s++
2341 @ GHC.Types.Char
2342 Main.scanBoard_z
2343 ww3
2344 ww4 }))
2345 GHC.Show.$fShow(,)4
2346 (case GHC.Show.$wshowSignedInt
2347 0#
2348 x
2349 (GHC.Types.:
2350 @ GHC.Types.Char
2351 GHC.Show.showList__1
2352 (GHC.Show.$fShow(,)_$sgo1
2353 Main.getColL17
2354 (\ (w2 :: GHC.Base.String)[OneShot] ->
2355 case j of ww2 { GHC.Types.I# ww3 ->
2356 case GHC.Show.$wshowSignedInt
2357 0#
2358 ww3
2359 w2 of ww4 { (#,#) ww5 ww6 ->
2360 GHC.Types.:
2361 @ GHC.Types.Char
2362 ww5
2363 ww6 } })
2364 (GHC.Types.[]
2365 @ GHC.Show.ShowS))) of ww4 { (#,#) ww5 ww6 ->
2366 GHC.Types.: @ GHC.Types.Char ww5 ww6 })))
2367 } in
2368 case GHC.Prim.># x dt of lwild {
2369 DEFAULT
2370 -> case j of wild4 { GHC.Types.I# x1 ->
2371 case GHC.Prim.># x1 dt1 of lwild1 {
2372 DEFAULT
2373 -> case GHC.Prim.<# x 1# of lwild2 {
2374 DEFAULT
2375 -> case GHC.Prim.<# x1 1# of lwild3 {
2376 DEFAULT
2377 -> case ds1 of wild5 { Data.Vector.Vector dt5 dt6 dt7 ->
2378 case GHC.Prim.indexArray#
2379 @ a
2380 dt7
2381 (GHC.Prim.-#
2382 (GHC.Prim.+#
2383 dt5
2384 (GHC.Prim.+#
2385 (GHC.Prim.*#
2386 (GHC.Prim.-#
2387 (GHC.Prim.+# x dt2)
2388 1#)
2389 dt4)
2390 (GHC.Prim.+# x1 dt3)))
2391 1#) of ds2 { Unit# ipv ->
2392 ipv } }
2393 1# -> $j }
2394 1# -> $j }
2395 1# -> $j } }
2396 1# -> $j } } })
2397 s1 of wild2 {
2398 GHC.Types.False -> go1 ys
2399 GHC.Types.True
2400 -> GHC.Types.:
2401 @ (GHC.Types.Int, GHC.Types.Int)
2402 wild1
2403 (go1 ys) } } }
2404 } in
2405 go1 Main.allPositions) -}
2406ba4d206db78a5cdc12cbc5213b6efa45
2407 scanBoard1 :: GHC.Prim.Addr#
2408 {- HasNoCafRefs, Unfolding: (" matrix."#) -}
2409dd473e64c7fd49868fbead83c5d37d7c
2410 scanBoard_z :: [GHC.Types.Char]
2411 {- Unfolding: (GHC.CString.unpackCString# Main.scanBoard1) -}
2412730d75bde90b9d85a238ada997a4cedb
2413 solve ::
2414 (GHC.Classes.Ord t, GHC.Num.Num t) =>
2415 t -> [Data.Matrix.Matrix Main.Square]
2416 {- Arity: 3,
2417 Strictness: <S(LLC(C(S))LLLLL),1*U(1*U(C(C1(U)),A),A,1*C1(C1(U)),A,1*C1(C1(U)),A,A,A)><L,U(A,C(C1(U)),A,A,A,A,C(U))><L,U>,
2418 Inline: [2],
2419 Unfolding: InlineRule (3, True, False)
2420 (\ @ t (w1 :: GHC.Classes.Ord t) (w2 :: GHC.Num.Num t) (w3 :: t) ->
2421 case w1 of ww { GHC.Classes.C:Ord ww1 ww2 ww3 ww4 ww5 ww6 ww7 ww8 ->
2422 Main.$wsolve @ t ww1 ww3 ww5 w2 w3 }) -}
2423bf34852c4989cdd534e45ed8798f1cc1
2424 solve1 :: [Data.Matrix.Matrix Main.Square]
2425 {- Unfolding: (GHC.Base.++
2426 @ (Data.Matrix.Matrix Main.Square)
2427 (Main.solve2 Main.initBoard)
2428 (GHC.Types.[] @ (Data.Matrix.Matrix Main.Square))) -}
2429e1e9b7845f8b9b9dd2f50c649384dcaf
2430 solve2 ::
2431 Data.Matrix.Matrix Main.Square -> [Data.Matrix.Matrix Main.Square]
2432 {- Arity: 1, Strictness: <L,U(U,U,U,U,U,U(U,A,U))>,
2433 Unfolding: (\ (b :: Data.Matrix.Matrix Main.Square) ->
2434 GHC.Base.map
2435 @ (GHC.Types.Int, GHC.Types.Int)
2436 @ (Data.Matrix.Matrix Main.Square)
2437 (\ (p :: (GHC.Types.Int, GHC.Types.Int)) -> Main.placeQueen p b)
2438 (Main.nextAvail_$sscanBoard Main.O b)) -}
2439c184a666bff831ddddecc4b865dff3df
2440 solve_go ::
2441 [Data.Matrix.Matrix Main.Square]
2442 -> [Data.Matrix.Matrix Main.Square]
2443 {- Arity: 1, Strictness: <S,1*U> -}
24447a7a57dbb9af5196c25058ab4a74fa7b
2445 w :: [Data.Matrix.Matrix Main.Square]
2446 {- Unfolding: (Main.$wwinners'
2447 @ GHC.Integer.Type.Integer
2448 Main.initBoard) -}
24494574f1ee92f6f2d180c8f1d8da82d147
2450 winnable :: a
2451 {- Strictness: x -}
2452a4252cdb991d662ac35e424364aba1a6
2453 winners ::
2454 (GHC.Classes.Eq p, GHC.Num.Num p) =>
2455 p
2456 -> [Data.Matrix.Matrix Main.Square]
2457 -> [Data.Matrix.Matrix Main.Square]
2458 {- Arity: 4,
2459 Strictness: <S(C(C(S))L),1*U(C(C1(U)),A)><L,U(A,C(C1(U)),A,A,A,A,C(U))><L,U><S,1*U>,
2460 Inline: [2],
2461 Unfolding: InlineRule (4, True, False)
2462 (\ @ p
2463 (w1 :: GHC.Classes.Eq p)
2464 (w2 :: GHC.Num.Num p)
2465 (w3 :: p)
2466 (w4 :: [Data.Matrix.Matrix Main.Square]) ->
2467 case w1 of ww { GHC.Classes.C:Eq ww1 ww2 ->
2468 Main.$wwinners @ p ww1 w2 w3 w4 }) -}
24693fcc2cf6408df510d613a4b754ea3680
2470 winners' ::
2471 p
2472 -> Data.Matrix.Matrix Main.Square
2473 -> [Data.Matrix.Matrix Main.Square]
2474 {- Arity: 2, Strictness: <L,A><L,U(U,U,U,U,U,U(U,A,U))>,
2475 Inline: [2],
2476 Unfolding: InlineRule (2, True, True)
2477 (\ @ p (w1 :: p) (w2 :: Data.Matrix.Matrix Main.Square) ->
2478 Main.$wwinners' @ p w2) -}
24798c043a319c68bd087e5d8643d5ba7d9d
2480 winners1 ::
2481 [Data.Matrix.Matrix Main.Square]
2482 -> [Data.Matrix.Matrix Main.Square]
2483 {- Arity: 1, Strictness: <S,1*U> -}
24843b9dd7cd56ddb92f4921e9fe96b4dd83
2485 winners_go ::
2486 [Data.Matrix.Matrix Main.Square]
2487 -> [Data.Matrix.Matrix Main.Square]
2488 {- Arity: 1, Strictness: <S,1*U> -}
2489instance GHC.Classes.Eq [Main.Square] = Main.$fEqSquare
2490instance GHC.Show.Show [Main.Square] = Main.$fShowSquare
2491"SPEC scanBoard @ Square" forall ($dEq :: GHC.Classes.Eq
2492 Main.Square)
2493 Main.scanBoard @ Main.Square $dEq = Main.nextAvail_$sscanBoard
2494"SPEC/Main $fEq(,) @ Int @ Int" [orphan] forall (v1 :: GHC.Classes.Eq
2495 GHC.Types.Int)
2496 (v :: GHC.Classes.Eq GHC.Types.Int)
2497 GHC.Classes.$fEq(,) @ GHC.Types.Int @ GHC.Types.Int v v1
2498 = Main.$s$fEq(,)
2499"SPEC/Main $fEq(,)_$c/= @ Int @ Int" [orphan] forall ($dEq1 :: GHC.Classes.Eq
2500 GHC.Types.Int)
2501 ($dEq :: GHC.Classes.Eq GHC.Types.Int)
2502 GHC.Classes.$fEq(,)_$c/= @ GHC.Types.Int @ GHC.Types.Int $dEq $dEq1
2503 = Main.$s$fEq(,)_$s$fEq(,)_$c/=
2504"SPEC/Main subtract @ Int" [orphan] forall ($dNum :: GHC.Num.Num
2505 GHC.Types.Int)
2506 GHC.Num.subtract @ GHC.Types.Int $dNum = Main.$ssubtract
2507"SPEC/Main subtract @ Integer" [orphan] forall ($dNum :: GHC.Num.Num
2508 GHC.Integer.Type.Integer)
2509 GHC.Num.subtract @ GHC.Integer.Type.Integer $dNum
2510 = Main.$ssubtract1
2511trusted: none
2512require own pkg trusted: False
2513module header:
2514 Nothing
2515declaration docs:
2516arg docs:
2517
generated by cgit v1.2.3 (git 2.39.1) at 2024-04-20 04:13:16 +0000