From cbe440bb0adbfbccfdbbcedb29bf9408c0596866 Mon Sep 17 00:00:00 2001 From: Steven Date: Wed, 29 May 2019 20:06:05 -0400 Subject: Initial repository; needs clean up but it's working so let's not lose it --- .../build/8queens/8queens-tmp/src/Main.dump-hi | 2517 ++++++++++++++++++++ 1 file changed, 2517 insertions(+) create mode 100644 .stack-work/dist/x86_64-linux/Cabal-2.4.0.1/build/8queens/8queens-tmp/src/Main.dump-hi (limited to '.stack-work/dist/x86_64-linux/Cabal-2.4.0.1/build/8queens/8queens-tmp/src/Main.dump-hi') 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 new file mode 100644 index 0000000..f380580 --- /dev/null +++ b/.stack-work/dist/x86_64-linux/Cabal-2.4.0.1/build/8queens/8queens-tmp/src/Main.dump-hi @@ -0,0 +1,2517 @@ + +==================== FINAL INTERFACE ==================== +2019-05-29 23:57:35.287700482 UTC + +interface main:Main 8065 + interface hash: 47c5f1b0ac88d7964b8d3ff4b4c5ad24 + ABI hash: 6a25402bbb47d2db70b5fccc80b8cd10 + export-list hash: 14799b7f7205366154cf4737867653f6 + orphan hash: 544728fd6478f60c87fd98f72c918bf5 + flag hash: 1638722aa932cf70c70adfffb210f5e7 + opt_hash: 6faf2de08de32d19db9870899d88e59a + hpc_hash: 93b885adfe0da089cdf634904fd59f71 + plugin_hash: ad164012d6b1e14942349d58b1132007 + sig of: Nothing + used TH splices: False + where +exports: + Main.allPositions + Main.allops + Main.applyop + Main.applyops + Main.diag + Main.diag'' + Main.getColL + Main.getDiagL + Main.getRowColDiag + Main.getRowL + Main.initBoard + Main.isWinnable + Main.isWinnable' + Main.lo8 + Main.main + Main.mapDiag + Main.mapQueensPath + Main.mapRowColDiag + Main.markX + Main.nextAvail + Main.nextOpen + Main.onBoard + Main.openPositions + Main.ops + Main.placeQueen + Main.placeQueen' + Main.queenAllowed + Main.s + Main.scanBoard + Main.solve + Main.w + Main.winnable + Main.winners + Main.winners' + Main.Square{Main.O Main.Qu Main.T Main.X} +module dependencies: +package dependencies: StateVar-1.1.1.1 adjunctions-4.4 + array-0.5.3.0 base-4.12.0.0 base-orphans-0.8.1 bifunctors-5.5.4 + binary-0.8.6.0 bytes-0.15.5 bytestring-0.10.8.2 call-stack-0.1.0 + cereal-0.5.8.0 comonad-5.0.5 containers-0.6.0.1 contravariant-1.5.1 + deepseq-1.4.4.0 distributive-0.6 exceptions-0.10.2 free-5.1.1 + ghc-boot-th-8.6.5 ghc-prim-0.5.3 hashable-1.2.7.0 + integer-gmp-1.0.2.0 integer-logarithms-1.0.3 kan-extensions-5.2 + lens-4.17.1 linear-1.20.9 loop-0.3.0 matrix-0.3.6.1 mtl-2.2.2 + pretty-1.1.3.6 primitive-0.6.4.0 profunctors-5.3 random-1.1 + reflection-2.1.4 scientific-0.3.6.2 semigroupoids-5.3.2 stm-2.5.0.0 + tagged-0.8.6 template-haskell-2.14.0.0 text-1.2.3.1 + th-abstraction-0.2.11.0 time-1.8.0.2 transformers-0.5.6.2 + transformers-base-0.4.5.2 transformers-compat-0.6.5 + unordered-containers-0.2.9.0 vector-0.12.0.3 +orphans: time-1.8.0.2:Data.Time.Clock.TAI + reflection-2.1.4:Data.Reflection + vector-0.12.0.3:Data.Vector.Unboxed stm-2.5.0.0:Control.Monad.STM + hashable-1.2.7.0:Data.Hashable.Generic text-1.2.3.1:Data.Text.Lazy + text-1.2.3.1:Data.Text binary-0.8.6.0:Data.Binary.Generic + bytestring-0.10.8.2:Data.ByteString.Builder + text-1.2.3.1:Data.Text.Show linear-1.20.9:Linear.Instances + vector-0.12.0.3:Data.Vector.Fusion.Bundle + transformers-0.5.6.2:Control.Monad.Trans.Error + time-1.8.0.2:Data.Time.Format.Parse + time-1.8.0.2:Data.Time.LocalTime.Internal.ZonedTime + time-1.8.0.2:Data.Time.LocalTime.Internal.LocalTime + time-1.8.0.2:Data.Time.Calendar.Gregorian base-4.12.0.0:GHC.Float + base-4.12.0.0:GHC.Base +family instance modules: adjunctions-4.4:Data.Functor.Rep + base-4.12.0.0:Control.Applicative base-4.12.0.0:Data.Complex + base-4.12.0.0:Data.Functor.Compose base-4.12.0.0:Data.Functor.Const + base-4.12.0.0:Data.Functor.Identity + base-4.12.0.0:Data.Functor.Product base-4.12.0.0:Data.Functor.Sum + base-4.12.0.0:Data.Monoid base-4.12.0.0:Data.Semigroup + base-4.12.0.0:Data.Semigroup.Internal base-4.12.0.0:Data.Version + base-4.12.0.0:Data.Void base-4.12.0.0:GHC.Exts + base-4.12.0.0:GHC.Generics base-4.12.0.0:GHC.IO.Exception + bifunctors-5.5.4:Data.Bifunctor.Biff + bifunctors-5.5.4:Data.Bifunctor.Clown + bifunctors-5.5.4:Data.Bifunctor.Fix + bifunctors-5.5.4:Data.Bifunctor.Flip + bifunctors-5.5.4:Data.Bifunctor.Join + bifunctors-5.5.4:Data.Bifunctor.Joker + bifunctors-5.5.4:Data.Bifunctor.Product + bifunctors-5.5.4:Data.Bifunctor.Sum + bifunctors-5.5.4:Data.Bifunctor.Tannen + bifunctors-5.5.4:Data.Bifunctor.Wrapped bytes-0.15.5:Data.Bytes.Get + bytes-0.15.5:Data.Bytes.Signed bytes-0.15.5:Data.Bytes.VarInt + containers-0.6.0.1:Data.IntMap.Internal + containers-0.6.0.1:Data.IntSet.Internal + containers-0.6.0.1:Data.Map.Internal + containers-0.6.0.1:Data.Sequence.Internal + containers-0.6.0.1:Data.Set.Internal containers-0.6.0.1:Data.Tree + free-5.1.1:Control.Comonad.Cofree + free-5.1.1:Control.Comonad.Trans.Cofree + free-5.1.1:Control.Monad.Free free-5.1.1:Control.Monad.Trans.Free + ghc-boot-th-8.6.5:GHC.ForeignSrcLang.Type + ghc-boot-th-8.6.5:GHC.LanguageExtensions.Type + kan-extensions-5.2:Data.Functor.Day + kan-extensions-5.2:Data.Functor.Yoneda lens-4.17.1:Control.Lens.At + lens-4.17.1:Control.Lens.Internal.Indexed + lens-4.17.1:Control.Lens.Reified lens-4.17.1:Control.Lens.Tuple + lens-4.17.1:Control.Lens.Wrapped lens-4.17.1:Control.Lens.Zoom + linear-1.20.9:Linear.V linear-1.20.9:Linear.V1 + linear-1.20.9:Linear.V2 linear-1.20.9:Linear.V3 + matrix-0.3.6.1:Data.Matrix + pretty-1.1.3.6:Text.PrettyPrint.Annotated.HughesPJ + pretty-1.1.3.6:Text.PrettyPrint.HughesPJ + primitive-0.6.4.0:Control.Monad.Primitive + primitive-0.6.4.0:Data.Primitive.Array + primitive-0.6.4.0:Data.Primitive.ByteArray + primitive-0.6.4.0:Data.Primitive.PrimArray + primitive-0.6.4.0:Data.Primitive.SmallArray + primitive-0.6.4.0:Data.Primitive.UnliftedArray + profunctors-5.3:Data.Profunctor.Composition + profunctors-5.3:Data.Profunctor.Rep tagged-0.8.6:Data.Tagged + template-haskell-2.14.0.0:Language.Haskell.TH.Syntax + text-1.2.3.1:Data.Text text-1.2.3.1:Data.Text.Lazy + th-abstraction-0.2.11.0:Language.Haskell.TH.Datatype + unordered-containers-0.2.9.0:Data.HashMap.Base + unordered-containers-0.2.9.0:Data.HashSet + vector-0.12.0.3:Data.Vector vector-0.12.0.3:Data.Vector.Primitive + vector-0.12.0.3:Data.Vector.Storable + vector-0.12.0.3:Data.Vector.Unboxed + vector-0.12.0.3:Data.Vector.Unboxed.Base +import -/ base-4.12.0.0:Control.Applicative 2ae514eb141d45774730765c61bb41c0 +import -/ base-4.12.0.0:Data.Foldable efb37371da929e7bc88d896298d2d979 +import -/ base-4.12.0.0:Data.List 17d0c71c557e42abe196f130788fd997 +import -/ base-4.12.0.0:Data.OldList e931cf456dc87f11ee6e6fb153bca23e +import -/ base-4.12.0.0:Data.Tuple c719fc29608fe81c10bee9a1bf1e05ff +import -/ base-4.12.0.0:Foreign.Storable 379843bb6beffe814f03155babd3a2a1 +import -/ base-4.12.0.0:GHC.Base c00b75f0b052d05c55ba6a4dd1c63b26 +import -/ base-4.12.0.0:GHC.Err ea5e313ef4146b40b5d8b27aa168e736 +import -/ base-4.12.0.0:GHC.List 4014a3c8a3b7c31c8325f6bcf1feea4a +import -/ base-4.12.0.0:GHC.Num c2039f03637c68f47b0bbff4c18ec616 +import -/ base-4.12.0.0:GHC.Show 838a5d039379d82d9626aae53dfce276 +import -/ base-4.12.0.0:Prelude 3c779dfd6448bdd8e234c336802c2acb +import -/ base-4.12.0.0:System.IO dd4f3cfe73b94b7cae46a4ca98a3f09f +import -/ ghc-prim-0.5.3:GHC.Classes 0f6fd7d7db53fc48f6e1f01803cc6c9d +import -/ ghc-prim-0.5.3:GHC.Types 57064c9f957b09bc2e360061ad5cae0b +import -/ lens-4.17.1:Control.Lens 3653945a21240fa9b051785ff6456731 +import -/ linear-1.20.9:Linear.V2 d56aa147d201434486a0d7613b12118c +import -/ linear-1.20.9:Linear.V3 1dcebeca95d66b9152a160ce7257a571 +import -/ matrix-0.3.6.1:Data.Matrix 352cbb223ecd1589261f36f7ff17bc9c +import -/ random-1.1:System.Random c6898761a03910f08acbe56f79c5fa96 +import -/ vector-0.12.0.3:Data.Vector 2f7b7a0ec8b90d2d82b017d1a022e0b2 +636ccc849665ce7c3156c440898486e4 + $fEqSquare :: GHC.Classes.Eq Main.Square + DFunId + {- HasNoCafRefs, Strictness: m, Inline: CONLIKE, + Unfolding: DFun:. + @ Main.Square Main.$fEqSquare_$c== Main.$fEqSquare_$c/= -} +636ccc849665ce7c3156c440898486e4 + $fEqSquare_$c/= :: Main.Square -> Main.Square -> GHC.Types.Bool + {- Arity: 2, HasNoCafRefs, Strictness: , + Inline: (sat-args=2), + Unfolding: InlineRule (2, False, False) + (\ (x :: Main.Square) (y :: Main.Square) -> + case x of wild { + Main.X + -> case y of wild1 { + DEFAULT -> GHC.Types.True Main.X -> GHC.Types.False } + Main.Qu + -> case y of wild1 { + DEFAULT -> GHC.Types.True Main.Qu -> GHC.Types.False } + Main.O + -> case y of wild1 { + DEFAULT -> GHC.Types.True Main.O -> GHC.Types.False } + Main.T + -> case y of wild1 { + DEFAULT -> GHC.Types.True Main.T -> GHC.Types.False } }) -} +636ccc849665ce7c3156c440898486e4 + $fEqSquare_$c== :: Main.Square -> Main.Square -> GHC.Types.Bool + {- Arity: 2, HasNoCafRefs, Strictness: , + Unfolding: (\ (ds :: Main.Square) (ds1 :: Main.Square) -> + case ds of wild { + Main.X + -> case ds1 of wild1 { + DEFAULT -> GHC.Types.False Main.X -> GHC.Types.True } + Main.Qu + -> case ds1 of wild1 { + DEFAULT -> GHC.Types.False Main.Qu -> GHC.Types.True } + Main.O + -> case ds1 of wild1 { + DEFAULT -> GHC.Types.False Main.O -> GHC.Types.True } + Main.T + -> case ds1 of wild1 { + DEFAULT -> GHC.Types.False Main.T -> GHC.Types.True } }) -} +636ccc849665ce7c3156c440898486e4 + $fShowSquare :: GHC.Show.Show Main.Square + DFunId + {- Strictness: m, Inline: CONLIKE, + Unfolding: DFun:. + @ Main.Square + Main.$fShowSquare_$cshowsPrec + Main.$fShowSquare_$cshow + Main.$fShowSquare_$cshowList -} +4034c5a8da4227c6e128ffb263a94e31 + $fShowSquare1 :: [GHC.Types.Char] + {- Unfolding: (GHC.CString.unpackCString# Main.$fShowSquare2) -} +83314de2c755664d070f9c06df865e32 + $fShowSquare2 :: GHC.Prim.Addr# + {- HasNoCafRefs, Unfolding: ("T"#) -} +49ff713629ce3b98fedf0d710cd5834f + $fShowSquare3 :: [GHC.Types.Char] + {- Unfolding: (GHC.CString.unpackCString# Main.$fShowSquare4) -} +15c027c2ef0f750ada425ea516d40011 + $fShowSquare4 :: GHC.Prim.Addr# + {- HasNoCafRefs, Unfolding: ("O"#) -} +a85da46c93392bfafc9def26682718a0 + $fShowSquare5 :: [GHC.Types.Char] + {- Unfolding: (GHC.CString.unpackCString# Main.$fShowSquare6) -} +2ab4bcdf43d08eb2889562449df03bd4 + $fShowSquare6 :: GHC.Prim.Addr# + {- HasNoCafRefs, Unfolding: ("Qu"#) -} +e23edf746cf45789786f8cf7d218e23c + $fShowSquare7 :: [GHC.Types.Char] + {- Unfolding: (GHC.CString.unpackCString# Main.$fShowSquare8) -} +0f48faaafde9dbcb6bdc9acd532c3d1f + $fShowSquare8 :: GHC.Prim.Addr# + {- HasNoCafRefs, Unfolding: ("X"#) -} +636ccc849665ce7c3156c440898486e4 + $fShowSquare_$cshow :: Main.Square -> GHC.Base.String + {- Arity: 1, Strictness: , + Unfolding: InlineRule (1, True, False) + (\ (x :: Main.Square) -> + case x of wild { + Main.X -> Main.$fShowSquare7 + Main.Qu -> Main.$fShowSquare5 + Main.O -> Main.$fShowSquare3 + Main.T -> Main.$fShowSquare1 }) -} +636ccc849665ce7c3156c440898486e4 + $fShowSquare_$cshowList :: [Main.Square] -> GHC.Show.ShowS + {- Arity: 2, Strictness: , + Unfolding: InlineRule (2, True, False) + (\ (ls :: [Main.Square]) (s1 :: GHC.Base.String) -> + GHC.Show.showList__ @ Main.Square Main.$w$cshowsPrec ls s1) -} +636ccc849665ce7c3156c440898486e4 + $fShowSquare_$cshowsPrec :: + GHC.Types.Int -> Main.Square -> GHC.Show.ShowS + {- Arity: 3, Strictness: , Inline: [2], + Unfolding: InlineRule (3, True, True) + (\ (w1 :: GHC.Types.Int) + (w2 :: Main.Square) + (w3 :: GHC.Base.String) -> + Main.$w$cshowsPrec w2 w3) -} +16f9cbadd6cc253275bae13256416fc2 + $s$fEq(,) :: GHC.Classes.Eq (GHC.Types.Int, GHC.Types.Int) + {- HasNoCafRefs, Strictness: m, Inline: CONLIKE, + Unfolding: DFun:. + @ (GHC.Types.Int, GHC.Types.Int) + (GHC.Classes.$fEq(,)_$c== + @ GHC.Types.Int + @ GHC.Types.Int + GHC.Classes.$fEqInt + GHC.Classes.$fEqInt) + Main.$s$fEq(,)_$s$fEq(,)_$c/= -} +d9c29de69e24759049df94d820948480 + $s$fEq(,)_$s$fEq(,)_$c/= :: + (GHC.Types.Int, GHC.Types.Int) + -> (GHC.Types.Int, GHC.Types.Int) -> GHC.Types.Bool + {- Arity: 2, HasNoCafRefs, + Strictness: , + Inline: (sat-args=2), + Unfolding: InlineRule (2, False, False) + (\ (x :: (GHC.Types.Int, GHC.Types.Int)) + (y :: (GHC.Types.Int, GHC.Types.Int)) -> + case x of wild { (,) a1 a2 -> + case y of wild1 { (,) b1 b2 -> + case GHC.Classes.eqInt a1 b1 of wild2 { + GHC.Types.False -> GHC.Types.True + GHC.Types.True + -> case GHC.Classes.eqInt a2 b2 of wild3 { + GHC.Types.False -> GHC.Types.True + GHC.Types.True -> GHC.Types.False } } } }) -} +a5aa05036c6055a96ceac3d767cdd7d3 + $ssubtract :: GHC.Types.Int -> GHC.Types.Int -> GHC.Types.Int + {- Arity: 2, HasNoCafRefs, Strictness: m, + Inline: (sat-args=2), + Unfolding: InlineRule (2, False, True) + (\ (x :: GHC.Types.Int) (y :: GHC.Types.Int) -> + GHC.Num.$fNumInt_$c- y x) -} +4b1b8958426064b7d9309d9d2fdefe7c + $ssubtract1 :: + GHC.Integer.Type.Integer + -> GHC.Integer.Type.Integer -> GHC.Integer.Type.Integer + {- Arity: 2, Strictness: , Inline: (sat-args=2), + Unfolding: InlineRule (2, False, True) + (\ (x :: GHC.Integer.Type.Integer) + (y :: GHC.Integer.Type.Integer) -> + GHC.Integer.Type.minusInteger y x) -} +6611e1da6e72881a60833105d1d890e3 + $tc'O :: GHC.Types.TyCon + {- HasNoCafRefs, Strictness: m, + Unfolding: (GHC.Types.TyCon + 9675801932394384788## + 6712316648948115877## + Main.$trModule + Main.$tc'O2 + 0# + Main.$tc'O1) -} +be5d1f5fee02b88e4232cb81c2af2579 + $tc'O1 :: GHC.Types.KindRep + {- HasNoCafRefs, Strictness: m1, Inline: [~] -} +ff261ad5b24f7fdd4296a33c047646a3 + $tc'O2 :: GHC.Types.TrName + {- HasNoCafRefs, Strictness: m1, + Unfolding: (GHC.Types.TrNameS Main.$tc'O3) -} +ef99b4220de234abd7b20254f6eb8a41 + $tc'O3 :: GHC.Prim.Addr# + {- HasNoCafRefs, Unfolding: ("'O"#) -} +ee107ec2d080306c47caa0ad45ca2789 + $tc'Qu :: GHC.Types.TyCon + {- HasNoCafRefs, Strictness: m, + Unfolding: (GHC.Types.TyCon + 17979074984894399304## + 18119058677283552676## + Main.$trModule + Main.$tc'Qu1 + 0# + Main.$tc'O1) -} +aa91b9b113b846476e7a8ca91ca447fa + $tc'Qu1 :: GHC.Types.TrName + {- HasNoCafRefs, Strictness: m1, + Unfolding: (GHC.Types.TrNameS Main.$tc'Qu2) -} +ad8c06afed71d1de83408f6e00133f92 + $tc'Qu2 :: GHC.Prim.Addr# + {- HasNoCafRefs, Unfolding: ("'Qu"#) -} +41821a7de349be54ac630d2049b64a42 + $tc'T :: GHC.Types.TyCon + {- HasNoCafRefs, Strictness: m, + Unfolding: (GHC.Types.TyCon + 15564654814037795574## + 9702549696965301893## + Main.$trModule + Main.$tc'T1 + 0# + Main.$tc'O1) -} +82969608b13a211f112632f79676d867 + $tc'T1 :: GHC.Types.TrName + {- HasNoCafRefs, Strictness: m1, + Unfolding: (GHC.Types.TrNameS Main.$tc'T2) -} +187cc49652b02277d0b99ae5ea1a5fd9 + $tc'T2 :: GHC.Prim.Addr# + {- HasNoCafRefs, Unfolding: ("'T"#) -} +581a21f4a7e2a1d9b2996ff8c471b022 + $tc'X :: GHC.Types.TyCon + {- HasNoCafRefs, Strictness: m, + Unfolding: (GHC.Types.TyCon + 5225325308912582631## + 14983302646393556978## + Main.$trModule + Main.$tc'X1 + 0# + Main.$tc'O1) -} +3a2176738fada4904e3cf07296e7fdfd + $tc'X1 :: GHC.Types.TrName + {- HasNoCafRefs, Strictness: m1, + Unfolding: (GHC.Types.TrNameS Main.$tc'X2) -} +568425ffbb1010e85481e6073e42496e + $tc'X2 :: GHC.Prim.Addr# + {- HasNoCafRefs, Unfolding: ("'X"#) -} +dbf71b2385a61bc04046efc2d3fd1efc + $tcSquare :: GHC.Types.TyCon + {- HasNoCafRefs, Strictness: m, + Unfolding: (GHC.Types.TyCon + 10164887948691462873## + 15713138518001860047## + Main.$trModule + Main.$tcSquare1 + 0# + GHC.Types.krep$*) -} +375635f77e678ce251c5463aacfeeccd + $tcSquare1 :: GHC.Types.TrName + {- HasNoCafRefs, Strictness: m1, + Unfolding: (GHC.Types.TrNameS Main.$tcSquare2) -} +28ba19c10877e3323cf2c279f530ca96 + $tcSquare2 :: GHC.Prim.Addr# + {- HasNoCafRefs, Unfolding: ("Square"#) -} +be86c9d078d3acbf19ba91fe74a24273 + $trModule :: GHC.Types.Module + {- HasNoCafRefs, Strictness: m, + Unfolding: (GHC.Types.Module Main.$trModule3 Main.$trModule1) -} +b09d86f2c49dd5176b544d8d13ddb6c5 + $trModule1 :: GHC.Types.TrName + {- HasNoCafRefs, Strictness: m1, + Unfolding: (GHC.Types.TrNameS Main.$trModule2) -} +e5875966b74dad2d29772660b8a75e33 + $trModule2 :: GHC.Prim.Addr# + {- HasNoCafRefs, Unfolding: ("Main"#) -} +23b03bd7d075a00f5ad1ee10e6add7b8 + $trModule3 :: GHC.Types.TrName + {- HasNoCafRefs, Strictness: m1, + Unfolding: (GHC.Types.TrNameS Main.$trModule4) -} +d026be77cb9ced20e35a61514e0458aa + $trModule4 :: GHC.Prim.Addr# + {- HasNoCafRefs, Unfolding: ("main"#) -} +636ccc849665ce7c3156c440898486e4 + $w$cshowsPrec :: Main.Square -> GHC.Base.String -> GHC.Base.String + {- Arity: 2, Strictness: , Inline: [2], + Unfolding: (\ (w1 :: Main.Square) (w2 :: GHC.Base.String) -> + case w1 of wild { + Main.X -> GHC.Base.++ @ GHC.Types.Char Main.$fShowSquare7 w2 + Main.Qu -> GHC.Base.++ @ GHC.Types.Char Main.$fShowSquare5 w2 + Main.O -> GHC.Base.++ @ GHC.Types.Char Main.$fShowSquare3 w2 + Main.T -> GHC.Base.++ @ GHC.Types.Char Main.$fShowSquare1 w2 }) -} +98dbe0ea72c75ba926317b7f7608e4d8 + $wdiag :: + GHC.Prim.Int# + -> GHC.Types.Int + -> Data.Matrix.Matrix a + -> [(GHC.Types.Int, GHC.Types.Int)] + {- Arity: 3, HasNoCafRefs, + Strictness: , Inline: [2], + Unfolding: (\ @ a + (ww :: GHC.Prim.Int#) + (ww1 :: GHC.Types.Int) + (w1 :: Data.Matrix.Matrix a) -> + let { + $wc :: (GHC.Types.Int -> GHC.Types.Int) + -> (GHC.Types.Int -> GHC.Types.Int) + -> [(GHC.Types.Int, GHC.Types.Int)] + {- Arity: 2, Strictness: , Inline: [2] -} + = \ (ww2 :: GHC.Types.Int -> GHC.Types.Int) + (ww3 :: GHC.Types.Int -> GHC.Types.Int)[OneShot] -> + letrec { + $wgo2 :: GHC.Prim.Int# + -> GHC.Types.Int -> [(GHC.Types.Int, GHC.Types.Int)] + {- Arity: 2, Strictness: , Inline: [2] -} + = \ (ww4 :: GHC.Prim.Int#) (ww5 :: GHC.Types.Int) -> + case GHC.Prim.>=# ww4 1# of lwild { + DEFAULT -> GHC.Types.[] @ (GHC.Types.Int, GHC.Types.Int) + 1# + -> case w1 of wild { Data.Matrix.M dt dt1 dt2 dt3 dt4 ds1 -> + case GHC.Prim.<=# ww4 dt of lwild1 { + DEFAULT -> GHC.Types.[] @ (GHC.Types.Int, GHC.Types.Int) + 1# + -> case ww5 of wild1 { GHC.Types.I# x -> + case GHC.Prim.>=# x 1# of lwild2 { + DEFAULT -> GHC.Types.[] @ (GHC.Types.Int, GHC.Types.Int) + 1# + -> case GHC.Prim.<=# x dt1 of lwild3 { + DEFAULT -> GHC.Types.[] @ (GHC.Types.Int, GHC.Types.Int) + 1# + -> let { + i :: GHC.Types.Int = GHC.Types.I# ww4 + } in + GHC.Types.: + @ (GHC.Types.Int, GHC.Types.Int) + (i, wild1) + (case ww2 i of ww6 { GHC.Types.I# ww7 -> + $wgo2 ww7 (ww3 wild1) }) } } } } } } + } in + $wgo2 ww ww1 + } in + GHC.Base.++ + @ (GHC.Types.Int, GHC.Types.Int) + ($wc Main.diag_a Main.diag_a) + (GHC.Base.++ + @ (GHC.Types.Int, GHC.Types.Int) + ($wc Main.diag_a Main.diag_b) + (GHC.Base.++ + @ (GHC.Types.Int, GHC.Types.Int) + ($wc Main.diag_b Main.diag_a) + (GHC.Base.++ + @ (GHC.Types.Int, GHC.Types.Int) + ($wc Main.diag_b Main.diag_b) + (GHC.Types.[] @ (GHC.Types.Int, GHC.Types.Int)))))) -} +2caee5b49997123c1e51e55e4c8a1465 + $wdiag'' :: + (GHC.Num.Num b, GHC.Enum.Enum b, GHC.Num.Num a) => + (a -> a -> [a]) -> a -> b -> [(a, b)] + {- Arity: 6, HasNoCafRefs, + Strictness: , + Inline: [2] -} +e7b8a501f5fd9578b49e2b724f683bc8 + $wgetDiagL :: + GHC.Prim.Int# -> GHC.Types.Int -> Data.Matrix.Matrix a -> [a] + {- Arity: 3, Strictness: , + Inline: [2], + Unfolding: (\ @ a + (ww :: GHC.Prim.Int#) + (ww1 :: GHC.Types.Int) + (w1 :: Data.Matrix.Matrix a) -> + GHC.Base.map + @ (GHC.Types.Int, GHC.Types.Int) + @ a + (\ (x :: (GHC.Types.Int, GHC.Types.Int)) -> Data.Matrix.! @ a w1 x) + (Main.$wdiag @ a ww ww1 w1)) -} +11f7664f4ae85858621cfb12a0fb3060 + $wgetRowColDiag :: + GHC.Types.Int + -> GHC.Types.Int + -> GHC.Prim.Int# + -> GHC.Prim.Int# + -> GHC.Prim.Int# + -> GHC.Prim.Int# + -> GHC.Prim.Int# + -> Data.Vector.Vector a + -> [((GHC.Types.Int, GHC.Types.Int), a)] + {- Arity: 8, + Strictness: , + Inline: [2] -} +947a5776179f0c1f40c4a8ad30b9fd68 + $wgo :: [Main.Square] -> GHC.Prim.Int# -> GHC.Types.Int + {- Arity: 2, HasNoCafRefs, Strictness: m, + Inline: [2] -} +715619f66da8ee3670b7cc69be050c49 + $wisWinnable :: + GHC.Prim.Int# -> Data.Matrix.Matrix Main.Square -> GHC.Types.Bool + {- Arity: 2, Strictness: , + Inline: [2], + Unfolding: (\ (ww :: GHC.Prim.Int#) + (w1 :: Data.Matrix.Matrix Main.Square) -> + case GHC.Base.map + @ GHC.Types.Int + @ GHC.Types.Int + (\ (x :: GHC.Types.Int) -> + Main.$wgo (Main.getRowL @ Main.Square x w1) 0#) + Main.isWinnable1 of wild { + [] -> case GHC.List.maximum2 ret_ty GHC.Types.Bool of {} + : ipv ipv1 + -> case ipv of ww1 { GHC.Types.I# ww2 -> + case GHC.List.$wgo ipv1 ww2 of ww3 { DEFAULT -> + case GHC.Prim.<=# ww ww3 of lwild { + DEFAULT -> GHC.Types.False + 1# + -> case GHC.Base.map + @ GHC.Types.Int + @ GHC.Types.Int + (\ (x :: GHC.Types.Int) -> + Main.$wgo (Main.getColL @ Main.Square x w1) 0#) + Main.isWinnable1 of wild1 { + [] -> case GHC.List.maximum2 ret_ty GHC.Types.Bool of {} + : ipv2 ipv3 + -> case ipv2 of ww4 { GHC.Types.I# ww5 -> + case GHC.List.$wgo ipv3 ww5 of ww6 { DEFAULT -> + GHC.Prim.tagToEnum# + @ GHC.Types.Bool + (GHC.Prim.<=# ww ww6) } } } } } } }) -} +29e441a9726247d21b17947cf00c4bf0 + $wisWinnable' :: Data.Matrix.Matrix Main.Square -> [GHC.Types.Char] + {- Arity: 1, Strictness: , Inline: [2], + Unfolding: (\ @ p (w1 :: Data.Matrix.Matrix Main.Square) -> + GHC.CString.unpackAppendCString# + Main.isWinnable'2 + (case GHC.Base.map + @ GHC.Types.Int + @ GHC.Types.Int + (\ (x :: GHC.Types.Int) -> + Main.$wgo (Main.getRowL @ Main.Square x w1) 0#) + Main.isWinnable1 of wild { + [] -> case GHC.List.maximum2 ret_ty [GHC.Types.Char] of {} + : ipv ipv1 + -> case ipv of ww { GHC.Types.I# ww1 -> + case GHC.List.$wgo ipv1 ww1 of ww2 { DEFAULT -> + case GHC.Show.$wshowSignedInt + 0# + ww2 + (GHC.Types.[] @ GHC.Types.Char) of ww4 { (#,#) ww5 ww6 -> + GHC.Base.++_$s++ + @ GHC.Types.Char + (GHC.CString.unpackAppendCString# + Main.isWinnable'1 + (case GHC.Base.map + @ GHC.Types.Int + @ GHC.Types.Int + (\ (x :: GHC.Types.Int) -> + Main.$wgo (Main.getColL @ Main.Square x w1) 0#) + Main.isWinnable1 of wild1 { + [] -> case GHC.List.maximum2 ret_ty [GHC.Types.Char] of {} + : ipv2 ipv3 + -> case ipv2 of ww7 { GHC.Types.I# ww8 -> + case GHC.List.$wgo ipv3 ww8 of ww9 { DEFAULT -> + case GHC.Show.$wshowSignedInt + 0# + ww9 + (GHC.Types.[] + @ GHC.Types.Char) of ww10 { (#,#) ww11 ww12 -> + GHC.Types.: @ GHC.Types.Char ww11 ww12 } } } })) + ww5 + ww6 } } } })) -} +8247c69c6d133659d4fe141dff51dd1d + $wmapDiag :: + ((GHC.Types.Int, GHC.Types.Int) -> a -> a) + -> (GHC.Types.Int, GHC.Types.Int) + -> GHC.Prim.Int# + -> GHC.Prim.Int# + -> GHC.Prim.Int# + -> GHC.Prim.Int# + -> GHC.Prim.Int# + -> Data.Vector.Vector a + -> (# GHC.Prim.Int#, GHC.Prim.Int#, GHC.Prim.Int#, GHC.Prim.Int#, + GHC.Prim.Int#, Data.Vector.Vector a #) + {- Arity: 8, + Strictness: , + Inline: [2] -} +e1877462335ec1fb231f811fd98a6bec + $wmapRowColDiag :: + ((GHC.Types.Int, GHC.Types.Int) -> a -> a) + -> GHC.Types.Int + -> GHC.Types.Int + -> GHC.Prim.Int# + -> GHC.Prim.Int# + -> GHC.Prim.Int# + -> GHC.Prim.Int# + -> GHC.Prim.Int# + -> Data.Vector.Vector a + -> (# GHC.Prim.Int#, GHC.Prim.Int#, GHC.Prim.Int#, GHC.Prim.Int#, + GHC.Prim.Int#, Data.Vector.Vector a #) + {- Arity: 9, + Strictness: , + Inline: [2] -} +d7372687809e115753d3bf6bcf601536 + $wmarkX :: + (GHC.Types.Int, GHC.Types.Int) + -> GHC.Prim.Int# + -> GHC.Prim.Int# + -> GHC.Prim.Int# + -> GHC.Prim.Int# + -> GHC.Prim.Int# + -> Data.Vector.Vector Main.Square + -> (# GHC.Prim.Int#, GHC.Prim.Int#, GHC.Prim.Int#, GHC.Prim.Int#, + GHC.Prim.Int#, Data.Vector.Vector Main.Square #) + {- Arity: 7, + Strictness: , + Inline: [2], + Unfolding: (\ (w1 :: (GHC.Types.Int, GHC.Types.Int)) + (ww :: GHC.Prim.Int#) + (ww1 :: GHC.Prim.Int#) + (ww2 :: GHC.Prim.Int#) + (ww3 :: GHC.Prim.Int#) + (ww4 :: GHC.Prim.Int#) + (ww5 :: Data.Vector.Vector Main.Square) -> + (# ww, ww1, ww2, ww3, ww4, + case ww5 of v2 { Data.Vector.Vector ipv ipv1 ipv2 -> + case GHC.Magic.runRW# + @ ('GHC.Types.TupleRep + '[ 'GHC.Types.TupleRep '[], 'GHC.Types.LiftedRep]) + @ (# GHC.Prim.State# GHC.Prim.RealWorld, + Data.Vector.Vector Main.Square #) + (\ (s1 :: GHC.Prim.State# GHC.Prim.RealWorld)[OneShot] -> + case GHC.Prim.>=# ipv1 0# of lwild { + DEFAULT + -> case Main.markX2 ipv1 + ret_ty (# GHC.Prim.State# GHC.Prim.RealWorld, + Data.Vector.Vector Main.Square #) + of {} + 1# + -> case GHC.Prim.newArray# + @ Main.Square + @ (Control.Monad.Primitive.PrimState + (GHC.ST.ST GHC.Prim.RealWorld)) + ipv1 + (Data.Vector.Mutable.uninitialised @ Main.Square) + s1 + `cast` + (GHC.Prim.State# + (Sym (Control.Monad.Primitive.D:R:PrimStateST[0] + _N)))_R of ds1 { (#,#) ipv3 ipv4 -> + case GHC.Prim.copyArray# + @ Main.Square + @ (Control.Monad.Primitive.PrimState + (GHC.ST.ST GHC.Prim.RealWorld)) + ipv2 + ipv + ipv4 + 0# + ipv1 + ipv3 of s'# { DEFAULT -> + case w1 of wild2 { (,) i j -> + case i of wild3 { GHC.Types.I# x1 -> + case j of wild4 { GHC.Types.I# x2 -> + let { + x :: GHC.Prim.Int# + = GHC.Prim.-# + (GHC.Prim.+# + (GHC.Prim.*# (GHC.Prim.-# (GHC.Prim.+# x1 ww2) 1#) ww4) + (GHC.Prim.+# x2 ww3)) + 1# + } in + case GHC.Prim.>=# x 0# of lwild1 { + DEFAULT + -> case Main.markX1 @ GHC.Prim.RealWorld x ipv1 + ret_ty (# GHC.Prim.State# GHC.Prim.RealWorld, + Data.Vector.Vector Main.Square #) + of {} + 1# + -> case GHC.Prim.<# x ipv1 of lwild2 { + DEFAULT + -> case Main.markX1 @ GHC.Prim.RealWorld x ipv1 + ret_ty (# GHC.Prim.State# GHC.Prim.RealWorld, + Data.Vector.Vector Main.Square #) + of {} + 1# + -> case GHC.Prim.writeArray# + @ (Control.Monad.Primitive.PrimState + (GHC.ST.ST GHC.Prim.RealWorld)) + @ Main.Square + ipv4 + x + Main.X + s'# of s'#1 { DEFAULT -> + case GHC.Prim.unsafeFreezeArray# + @ (Control.Monad.Primitive.PrimState + (GHC.ST.ST GHC.Prim.RealWorld)) + @ Main.Square + ipv4 + s'#1 of ds2 { (#,#) ipv5 ipv6 -> + (# ipv5 + `cast` + (GHC.Prim.State# + (Control.Monad.Primitive.D:R:PrimStateST[0] + _N))_R, + Data.Vector.Vector + @ Main.Square + 0# + ipv1 + ipv6 #) } } } } } } } } } }) of ds1 { (#,#) ipv3 ipv4 -> + ipv4 } } #)) -} +4085aa77d3428b41dae9dfa21d22b863 + $wnextAvail :: + GHC.Prim.Int# + -> GHC.Prim.Int# + -> GHC.Prim.Int# + -> GHC.Prim.Int# + -> GHC.Prim.Int# + -> Data.Vector.Vector Main.Square + -> (GHC.Types.Int, GHC.Types.Int) + {- Arity: 6, Strictness: m, + Inline: [2], + Unfolding: (\ (ww :: GHC.Prim.Int#) + (ww1 :: GHC.Prim.Int#) + (ww2 :: GHC.Prim.Int#) + (ww3 :: GHC.Prim.Int#) + (ww4 :: GHC.Prim.Int#) + (ww5 :: Data.Vector.Vector Main.Square) -> + case Main.nextAvail_$sscanBoard + Main.O + (Data.Matrix.M @ Main.Square ww ww1 ww2 ww3 ww4 ww5) of wild { + [] -> GHC.List.badHead @ (GHC.Types.Int, GHC.Types.Int) + : y ys + -> case y of ww6 { (,) ww7 ww8 -> + letrec { + go1 :: [((GHC.Types.Int, GHC.Types.Int), Main.Square)] + -> (GHC.Types.Int, GHC.Types.Int) + {- Arity: 1, Strictness: m -} + = \ (ds :: [((GHC.Types.Int, GHC.Types.Int), Main.Square)]) -> + case ds of wild1 { + [] -> ww6 + : y1 ys1 + -> case y1 of wild2 { (,) ds1 y2 -> + case y2 of wild3 { + DEFAULT -> GHC.List.badHead @ (GHC.Types.Int, GHC.Types.Int) + Main.O -> go1 ys1 } } } + } in + go1 + (Main.$wgetRowColDiag + @ Main.Square + ww7 + ww8 + ww + ww1 + ww2 + ww3 + ww4 + ww5) } }) -} +2e97ede5368f9c2d2ff84f5bb17c4af3 + $wplaceQueen :: + GHC.Types.Int + -> GHC.Types.Int + -> GHC.Prim.Int# + -> GHC.Prim.Int# + -> GHC.Prim.Int# + -> GHC.Prim.Int# + -> GHC.Prim.Int# + -> Data.Vector.Vector Main.Square + -> (# GHC.Prim.Int#, GHC.Prim.Int#, GHC.Prim.Int#, GHC.Prim.Int#, + GHC.Prim.Int#, Data.Vector.Vector Main.Square #) + {- Arity: 8, + Strictness: , + Inline: [2], + Unfolding: (\ (ww :: GHC.Types.Int) + (ww1 :: GHC.Types.Int) + (ww2 :: GHC.Prim.Int#) + (ww3 :: GHC.Prim.Int#) + (ww4 :: GHC.Prim.Int#) + (ww5 :: GHC.Prim.Int#) + (ww6 :: GHC.Prim.Int#) + (ww7 :: Data.Vector.Vector Main.Square) -> + case Main.$wmapRowColDiag + @ Main.Square + Main.placeQueen1 + ww + ww1 + ww2 + ww3 + ww4 + ww5 + ww6 + ww7 of ww8 { (#,,,,,#) ww9 ww10 ww11 ww12 ww13 ww14 -> + (# ww9, ww10, ww11, ww12, ww13, + case ww14 of v2 { Data.Vector.Vector ipv ipv1 ipv2 -> + case GHC.Magic.runRW# + @ ('GHC.Types.TupleRep + '[ 'GHC.Types.TupleRep '[], 'GHC.Types.LiftedRep]) + @ (# GHC.Prim.State# GHC.Prim.RealWorld, + Data.Vector.Vector Main.Square #) + (\ (s1 :: GHC.Prim.State# GHC.Prim.RealWorld)[OneShot] -> + case GHC.Prim.>=# ipv1 0# of lwild { + DEFAULT + -> case Main.markX2 ipv1 + ret_ty (# GHC.Prim.State# GHC.Prim.RealWorld, + Data.Vector.Vector Main.Square #) + of {} + 1# + -> case GHC.Prim.newArray# + @ Main.Square + @ (Control.Monad.Primitive.PrimState + (GHC.ST.ST GHC.Prim.RealWorld)) + ipv1 + (Data.Vector.Mutable.uninitialised @ Main.Square) + s1 + `cast` + (GHC.Prim.State# + (Sym (Control.Monad.Primitive.D:R:PrimStateST[0] + _N)))_R of ds1 { (#,#) ipv3 ipv4 -> + case GHC.Prim.copyArray# + @ Main.Square + @ (Control.Monad.Primitive.PrimState + (GHC.ST.ST GHC.Prim.RealWorld)) + ipv2 + ipv + ipv4 + 0# + ipv1 + ipv3 of s'# { DEFAULT -> + case ww of wild3 { GHC.Types.I# x1 -> + case ww1 of wild4 { GHC.Types.I# x2 -> + let { + x :: GHC.Prim.Int# + = GHC.Prim.-# + (GHC.Prim.+# + (GHC.Prim.*# (GHC.Prim.-# (GHC.Prim.+# x1 ww11) 1#) ww13) + (GHC.Prim.+# x2 ww12)) + 1# + } in + case GHC.Prim.>=# x 0# of lwild1 { + DEFAULT + -> case Main.markX1 @ GHC.Prim.RealWorld x ipv1 + ret_ty (# GHC.Prim.State# GHC.Prim.RealWorld, + Data.Vector.Vector Main.Square #) + of {} + 1# + -> case GHC.Prim.<# x ipv1 of lwild2 { + DEFAULT + -> case Main.markX1 @ GHC.Prim.RealWorld x ipv1 + ret_ty (# GHC.Prim.State# GHC.Prim.RealWorld, + Data.Vector.Vector Main.Square #) + of {} + 1# + -> case GHC.Prim.writeArray# + @ (Control.Monad.Primitive.PrimState + (GHC.ST.ST GHC.Prim.RealWorld)) + @ Main.Square + ipv4 + x + Main.Qu + s'# of s'#1 { DEFAULT -> + case GHC.Prim.unsafeFreezeArray# + @ (Control.Monad.Primitive.PrimState + (GHC.ST.ST GHC.Prim.RealWorld)) + @ Main.Square + ipv4 + s'#1 of ds2 { (#,#) ipv5 ipv6 -> + (# ipv5 + `cast` + (GHC.Prim.State# + (Control.Monad.Primitive.D:R:PrimStateST[0] + _N))_R, + Data.Vector.Vector + @ Main.Square + 0# + ipv1 + ipv6 #) } } } } } } } } }) of ds1 { (#,#) ipv3 ipv4 -> + ipv4 } } #) }) -} +8ef5fa9322c84b90e14eaeb7d5987990 + $wplaceQueen' :: + GHC.Types.Int + -> GHC.Types.Int + -> GHC.Prim.Int# + -> GHC.Prim.Int# + -> GHC.Prim.Int# + -> GHC.Prim.Int# + -> GHC.Prim.Int# + -> Data.Vector.Vector Main.Square + -> (# GHC.Prim.Int#, GHC.Prim.Int#, GHC.Prim.Int#, GHC.Prim.Int#, + GHC.Prim.Int#, Data.Vector.Vector Main.Square #) + {- Arity: 8, + Strictness: , + Inline: [2], + Unfolding: (\ (ww :: GHC.Types.Int) + (ww1 :: GHC.Types.Int) + (ww2 :: GHC.Prim.Int#) + (ww3 :: GHC.Prim.Int#) + (ww4 :: GHC.Prim.Int#) + (ww5 :: GHC.Prim.Int#) + (ww6 :: GHC.Prim.Int#) + (ww7 :: Data.Vector.Vector Main.Square) -> + case Data.Matrix.$wmapCol + @ Main.Square + (Main.placeQueen'_fX @ GHC.Types.Int @ Main.Square) + ww1 + ww2 + ww3 + ww4 + ww5 + ww6 + ww7 of ww8 { (#,,,,,#) ww9 ww10 ww11 ww12 ww13 ww14 -> + case Data.Matrix.$wmapRow + @ Main.Square + (Main.placeQueen'_fX @ GHC.Types.Int @ Main.Square) + ww + ww9 + ww10 + ww11 + ww12 + ww13 + ww14 of ww15 { (#,,,,,#) ww16 ww17 ww18 ww19 ww20 ww21 -> + (# ww16, ww17, ww18, ww19, ww20, + case ww21 of v2 { Data.Vector.Vector ipv ipv1 ipv2 -> + case GHC.Magic.runRW# + @ ('GHC.Types.TupleRep + '[ 'GHC.Types.TupleRep '[], 'GHC.Types.LiftedRep]) + @ (# GHC.Prim.State# GHC.Prim.RealWorld, + Data.Vector.Vector Main.Square #) + (\ (s1 :: GHC.Prim.State# GHC.Prim.RealWorld)[OneShot] -> + case GHC.Prim.>=# ipv1 0# of lwild { + DEFAULT + -> case Main.markX2 ipv1 + ret_ty (# GHC.Prim.State# GHC.Prim.RealWorld, + Data.Vector.Vector Main.Square #) + of {} + 1# + -> case GHC.Prim.newArray# + @ Main.Square + @ (Control.Monad.Primitive.PrimState + (GHC.ST.ST GHC.Prim.RealWorld)) + ipv1 + (Data.Vector.Mutable.uninitialised @ Main.Square) + s1 + `cast` + (GHC.Prim.State# + (Sym (Control.Monad.Primitive.D:R:PrimStateST[0] + _N)))_R of ds1 { (#,#) ipv3 ipv4 -> + case GHC.Prim.copyArray# + @ Main.Square + @ (Control.Monad.Primitive.PrimState + (GHC.ST.ST GHC.Prim.RealWorld)) + ipv2 + ipv + ipv4 + 0# + ipv1 + ipv3 of s'# { DEFAULT -> + case ww of wild3 { GHC.Types.I# x1 -> + case ww1 of wild4 { GHC.Types.I# x2 -> + let { + x :: GHC.Prim.Int# + = GHC.Prim.-# + (GHC.Prim.+# + (GHC.Prim.*# (GHC.Prim.-# (GHC.Prim.+# x1 ww18) 1#) ww20) + (GHC.Prim.+# x2 ww19)) + 1# + } in + case GHC.Prim.>=# x 0# of lwild1 { + DEFAULT + -> case Main.markX1 @ GHC.Prim.RealWorld x ipv1 + ret_ty (# GHC.Prim.State# GHC.Prim.RealWorld, + Data.Vector.Vector Main.Square #) + of {} + 1# + -> case GHC.Prim.<# x ipv1 of lwild2 { + DEFAULT + -> case Main.markX1 @ GHC.Prim.RealWorld x ipv1 + ret_ty (# GHC.Prim.State# GHC.Prim.RealWorld, + Data.Vector.Vector Main.Square #) + of {} + 1# + -> case GHC.Prim.writeArray# + @ (Control.Monad.Primitive.PrimState + (GHC.ST.ST GHC.Prim.RealWorld)) + @ Main.Square + ipv4 + x + Main.Qu + s'# of s'#1 { DEFAULT -> + case GHC.Prim.unsafeFreezeArray# + @ (Control.Monad.Primitive.PrimState + (GHC.ST.ST GHC.Prim.RealWorld)) + @ Main.Square + ipv4 + s'#1 of ds2 { (#,#) ipv5 ipv6 -> + (# ipv5 + `cast` + (GHC.Prim.State# + (Control.Monad.Primitive.D:R:PrimStateST[0] + _N))_R, + Data.Vector.Vector + @ Main.Square + 0# + ipv1 + ipv6 #) } } } } } } } } }) of ds1 { (#,#) ipv3 ipv4 -> + ipv4 } } #) } }) -} +c57b742ed68452b2e8b2cded00e72e1c + $wsolve :: + GHC.Classes.Eq t => + (t -> t -> GHC.Types.Bool) + -> (t -> t -> GHC.Types.Bool) + -> GHC.Num.Num t => t -> [Data.Matrix.Matrix Main.Square] + {- Arity: 5, + Strictness: , + Inline: [2], + Unfolding: (\ @ t + (ww :: GHC.Classes.Eq t) + (ww1 :: t -> t -> GHC.Types.Bool) + (ww2 :: t -> t -> GHC.Types.Bool) + (w1 :: GHC.Num.Num t) + (w2 :: t) -> + case ww1 w2 (GHC.Num.fromInteger @ t w1 Main.ops5) of wild { + GHC.Types.False + -> case ww2 w2 (GHC.Num.fromInteger @ t w1 Main.lo1) of wild1 { + GHC.Types.False + -> case ww of ww3 { GHC.Classes.C:Eq ww4 ww5 -> + let { + lvl12 :: t = GHC.Num.fromInteger @ t w1 Main.ops5 + } in + let { + lvl13 :: t = GHC.Num.fromInteger @ t w1 Main.lo2 + } in + letrec { + solveN :: t -> [Data.Matrix.Matrix Main.Square] + {- Arity: 1, Strictness: -} + = \ (ds :: t) -> + case ww4 ds lvl13 of wild2 { + GHC.Types.False + -> case ww4 ds lvl12 of wild3 { + GHC.Types.False + -> Main.solve_go (solveN (GHC.Num.- @ t w1 ds lvl12)) + GHC.Types.True -> Main.solve1 } + GHC.Types.True -> GHC.Types.[] @ (Data.Matrix.Matrix Main.Square) } + } in + solveN w2 } + GHC.Types.True -> GHC.Types.[] @ (Data.Matrix.Matrix Main.Square) } + GHC.Types.True + -> GHC.Types.[] @ (Data.Matrix.Matrix Main.Square) }) -} +f5d40babaf79dc225afeeacf39e71d14 + $wwinners :: + (p -> p -> GHC.Types.Bool) + -> GHC.Num.Num p => + p + -> [Data.Matrix.Matrix Main.Square] + -> [Data.Matrix.Matrix Main.Square] + {- Arity: 4, + Strictness: , + Inline: [2], + Unfolding: (\ @ p + (ww :: p -> p -> GHC.Types.Bool) + (w1 :: GHC.Num.Num p) + (w2 :: p) + (w3 :: [Data.Matrix.Matrix Main.Square]) -> + let { + lvl12 :: p = GHC.Num.fromInteger @ p w1 Main.ops5 + } in + letrec { + winners2 :: p + -> [Data.Matrix.Matrix Main.Square] + -> [Data.Matrix.Matrix Main.Square] + {- Arity: 2, Strictness: -} + = \ (ds :: p) (b :: [Data.Matrix.Matrix Main.Square]) -> + case ww ds lvl12 of wild { + GHC.Types.False + -> winners2 (GHC.Num.- @ p w1 ds lvl12) (Main.winners1 @ p b) + GHC.Types.True -> Main.winners_go b } + } in + winners2 w2 w3) -} +fc231a19666745198b5cad6fbcf77735 + $wwinners' :: + Data.Matrix.Matrix Main.Square -> [Data.Matrix.Matrix Main.Square] + {- Arity: 1, Strictness: , Inline: [2], + Unfolding: (\ @ p (w1 :: Data.Matrix.Matrix Main.Square) -> + letrec { + go1 :: [(GHC.Types.Int, GHC.Types.Int)] + -> [Data.Matrix.Matrix Main.Square] + {- Arity: 1, Strictness: -} + = \ (ds :: [(GHC.Types.Int, GHC.Types.Int)]) -> + case ds of wild { + [] -> GHC.Types.[] @ (Data.Matrix.Matrix Main.Square) + : y ys + -> case y of ww { (,) ww1 ww2 -> + case w1 of ww3 { Data.Matrix.M ww4 ww5 ww6 ww7 ww8 ww9 -> + let { + exit :: [Data.Matrix.Matrix Main.Square] + = GHC.Types.: + @ (Data.Matrix.Matrix Main.Square) + (case Main.$wplaceQueen + ww1 + ww2 + ww4 + ww5 + ww6 + ww7 + ww8 + ww9 of ww10 { (#,,,,,#) ww11 ww12 ww13 ww14 ww15 ww16 -> + Data.Matrix.M @ Main.Square ww11 ww12 ww13 ww14 ww15 ww16 }) + (go1 ys) + } in + let { + exit1 :: [Data.Matrix.Matrix Main.Square] = go1 ys + } in + letrec { + go2 :: [((GHC.Types.Int, GHC.Types.Int), Main.Square)] + -> [Data.Matrix.Matrix Main.Square] + {- Arity: 1, Strictness: -} + = \ (ds1 :: [((GHC.Types.Int, GHC.Types.Int), Main.Square)]) -> + case ds1 of wild1 { + [] -> exit + : y1 ys1 + -> case y1 of wild2 { (,) ds2 y2 -> + case y2 of wild3 { DEFAULT -> exit1 Main.O -> go2 ys1 } } } + } in + go2 + (Main.$wgetRowColDiag + @ Main.Square + ww1 + ww2 + ww4 + ww5 + ww6 + ww7 + ww8 + ww9) } } } + } in + go1 (Main.nextAvail_$sscanBoard Main.O w1)) -} +636ccc849665ce7c3156c440898486e4 + data Square = X | Qu | O | T +e6f15f421e1dad77000d8fc6a4ea855b + allPositions :: [(GHC.Types.Int, GHC.Types.Int)] + {- Unfolding: (Main.allPositions_go 1#) -} +346f770a613a5360df15e8c985bdce13 + allPositions_go :: + GHC.Prim.Int# -> [(GHC.Types.Int, GHC.Types.Int)] + {- Arity: 1, HasNoCafRefs, Strictness: -} +194ce8b8e7f8d37be79aac8aa28e9d44 + allops :: b -> b -> [(b, b)] + {- Arity: 2, HasNoCafRefs, Strictness: m2, + Unfolding: InlineRule (2, True, False) + (\ @ b (a :: b) (b1 :: b) -> + GHC.Types.: + @ (b, b) + (a, a) + (GHC.Types.: + @ (b, b) + (a, b1) + (GHC.Types.: + @ (b, b) + (b1, a) + (GHC.Types.: @ (b, b) (b1, b1) (GHC.Types.[] @ (b, b)))))) -} +1510beb52847e90895824612d049f264 + applyop :: (t1, t2) -> (t1 -> a, t2 -> b) -> (a, b) + {- Arity: 2, HasNoCafRefs, + Strictness: m, + Unfolding: InlineRule (2, True, False) + (\ @ t @ t1 @ a @ b (ds :: (t, t1)) (ds1 :: (t -> a, t1 -> b)) -> + case ds of wild { (,) x y -> + case ds1 of wild1 { (,) a1 b1 -> (a1 x, b1 y) } }) -} +6f09b815b2eac49fd5e364003153edb6 + applyops :: + (GHC.Integer.Type.Integer, GHC.Integer.Type.Integer) + -> [(GHC.Integer.Type.Integer, GHC.Integer.Type.Integer)] + {- Arity: 1, Strictness: , + Unfolding: InlineRule (1, True, False) + (\ (p :: (GHC.Integer.Type.Integer, GHC.Integer.Type.Integer)) -> + GHC.Base.build + @ (GHC.Integer.Type.Integer, GHC.Integer.Type.Integer) + (\ @ b1 + (c :: (GHC.Integer.Type.Integer, GHC.Integer.Type.Integer) + -> b1 -> b1)[OneShot] + (n :: b1)[OneShot] -> + GHC.Base.foldr + @ (GHC.Integer.Type.Integer -> GHC.Integer.Type.Integer, + GHC.Integer.Type.Integer -> GHC.Integer.Type.Integer) + @ b1 + (GHC.Base.mapFB + @ (GHC.Integer.Type.Integer, GHC.Integer.Type.Integer) + @ b1 + @ (GHC.Integer.Type.Integer -> GHC.Integer.Type.Integer, + GHC.Integer.Type.Integer -> GHC.Integer.Type.Integer) + c + (Main.applyop + @ GHC.Integer.Type.Integer + @ GHC.Integer.Type.Integer + @ GHC.Integer.Type.Integer + @ GHC.Integer.Type.Integer + p)) + n + Main.ops)) -} +3d3675529761c115a8648803688b15f0 + diag :: + (GHC.Types.Int, GHC.Types.Int) + -> Data.Matrix.Matrix a -> [(GHC.Types.Int, GHC.Types.Int)] + {- Arity: 2, HasNoCafRefs, + Strictness: , + Inline: [2], + Unfolding: InlineRule (2, True, False) + (\ @ a + (w1 :: (GHC.Types.Int, GHC.Types.Int)) + (w2 :: Data.Matrix.Matrix a) -> + case w1 of ww { (,) ww1 ww2 -> + case ww1 of ww3 { GHC.Types.I# ww4 -> + Main.$wdiag @ a ww4 ww2 w2 } }) -} +521caf14a897d9945170c2a83c7838bf + diag'' :: + (GHC.Num.Num b, GHC.Enum.Enum b, GHC.Num.Num a, GHC.Enum.Enum a) => + a -> b -> [(a, b)] + {- Arity: 6, HasNoCafRefs, + Strictness: , + Inline: [2], + Unfolding: InlineRule (6, True, False) + (\ @ b + @ a + (w1 :: GHC.Num.Num b) + (w2 :: GHC.Enum.Enum b) + (w3 :: GHC.Num.Num a) + (w4 :: GHC.Enum.Enum a) + (w5 :: a) + (w6 :: b) -> + case w4 of ww { GHC.Enum.C:Enum ww1 ww2 ww3 ww4 ww5 ww6 ww7 ww8 -> + Main.$wdiag'' @ b @ a w1 w2 w3 ww7 w5 w6 }) -} +2189f869b91b6ccf81bf4b6df23487af + diag1 :: GHC.Types.Int + {- HasNoCafRefs, Strictness: m, Unfolding: (GHC.Types.I# 1#) -} +4813f5027120582dc077480ee2be320f + diag_a :: GHC.Types.Int -> GHC.Types.Int + {- Arity: 1, HasNoCafRefs, Strictness: m, + Unfolding: InlineRule (1, True, False) + (\ (ds :: GHC.Types.Int) -> + case ds of wild { GHC.Types.I# x -> + GHC.Types.I# (GHC.Prim.+# x 1#) }) -} +90a1a91fcfdff7b345d5ba6f915f51fe + diag_b :: GHC.Types.Int -> GHC.Types.Int + {- Arity: 1, HasNoCafRefs, + Unfolding: (Main.$ssubtract Main.diag1) -} +d565538a2eaa3b46fc2f853fadab9e26 + getColL :: GHC.Types.Int -> Data.Matrix.Matrix b -> [b] + {- Arity: 2, Strictness: , + Unfolding: (\ @ b + (c :: GHC.Types.Int) + (b1 :: Data.Matrix.Matrix b) -> + let { + lvl12 :: GHC.Base.String + = GHC.Show.$fShow(,)_$sgo1 + Main.getColL17 + (\ (w2 :: GHC.Base.String)[OneShot] -> + case c of ww2 { GHC.Types.I# ww3 -> + case GHC.Show.$wshowSignedInt 0# ww3 w2 of ww4 { (#,#) ww5 ww6 -> + GHC.Types.: @ GHC.Types.Char ww5 ww6 } }) + (GHC.Types.[] @ GHC.Show.ShowS) + } in + let { + lvl13 :: [GHC.Types.Char] + = GHC.Types.: @ GHC.Types.Char GHC.Show.showList__1 lvl12 + } in + letrec { + go1 :: GHC.Prim.Int# -> [b] {- Arity: 1, Strictness: -} + = \ (x :: GHC.Prim.Int#) -> + GHC.Types.: + @ b + (case b1 of wild { Data.Matrix.M dt dt1 dt2 dt3 dt4 ds -> + let { + $j :: b {- Strictness: x -} + = GHC.Err.error + @ 'GHC.Types.LiftedRep + @ b + Main.getColL3 + `cast` + (Sym (GHC.Classes.N:IP[0] + <"callStack">_N _N)) + (GHC.CString.unpackAppendCString# + Main.getColL2 + (let { + z :: [GHC.Types.Char] + = GHC.CString.unpackAppendCString# + Main.getColL1 + (case Data.Matrix.$wsizeStr + dt + (GHC.Types.I# dt1) of ww2 { (#,#) ww3 ww4 -> + Main.getColL_go (GHC.Types.: @ GHC.Types.Char ww3 ww4) }) + } in + letrec { + go2 :: [GHC.Types.Char] -> [GHC.Types.Char] + {- Arity: 1, Strictness: -} + = \ (ds1 :: [GHC.Types.Char]) -> + case ds1 of wild1 { + [] -> z : y ys -> GHC.Types.: @ GHC.Types.Char y (go2 ys) } + } in + go2 + (GHC.Types.: + @ GHC.Types.Char + GHC.Show.$fShow(,)4 + (case GHC.Show.$wshowSignedInt + 0# + x + lvl13 of ww4 { (#,#) ww5 ww6 -> + GHC.Types.: @ GHC.Types.Char ww5 ww6 })))) + } in + case GHC.Prim.># x dt of lwild { + DEFAULT + -> case c of wild2 { GHC.Types.I# x1 -> + case GHC.Prim.># x1 dt1 of lwild1 { + DEFAULT + -> case GHC.Prim.<# x 1# of lwild2 { + DEFAULT + -> case GHC.Prim.<# x1 1# of lwild3 { + DEFAULT + -> case ds of wild3 { Data.Vector.Vector dt5 dt6 dt7 -> + case GHC.Prim.indexArray# + @ b + dt7 + (GHC.Prim.-# + (GHC.Prim.+# + dt5 + (GHC.Prim.+# + (GHC.Prim.*# + (GHC.Prim.-# (GHC.Prim.+# x dt2) 1#) + dt4) + (GHC.Prim.+# x1 dt3))) + 1#) of ds2 { Unit# ipv -> + ipv } } + 1# -> $j } + 1# -> $j } + 1# -> $j } } + 1# -> $j } }) + (case x of wild { + DEFAULT -> go1 (GHC.Prim.+# wild 1#) 8# -> GHC.Types.[] @ b }) + } in + go1 1#) -} +59a3d6e7a7d530f2d5917c5d492ef742 + getColL1 :: GHC.Prim.Addr# + {- HasNoCafRefs, Unfolding: (" element from a "#) -} +7b742804a973a371e3e88e2b04b6943d + getColL10 :: GHC.Prim.Addr# + {- HasNoCafRefs, Unfolding: ("./Data/Matrix.hs"#) -} +16a55bd560443de3787e26963c224d00 + getColL11 :: [GHC.Types.Char] + {- Unfolding: (GHC.CString.unpackCString# Main.getColL12) -} +49b261779522cf2cb70b366e5468ac70 + getColL12 :: GHC.Prim.Addr# + {- HasNoCafRefs, Unfolding: ("Data.Matrix"#) -} +92b62b416ca035d74d9f76c2d45db080 + getColL13 :: [GHC.Types.Char] + {- Unfolding: (GHC.CString.unpackCString# Main.getColL14) -} +d70fe03047f9d5d1fbd4af4cf9015d44 + getColL14 :: GHC.Prim.Addr# + {- HasNoCafRefs, + Unfolding: ("matrix-0.3.6.1-CUcUqfmsmAA7saz436AQSk"#) -} +3231f8c7d8c0936ef4d69ce873202d4f + getColL15 :: [GHC.Types.Char] + {- Unfolding: (GHC.CString.unpackCString# Main.getColL16) -} +c23d90f9195be571da707594d1a5f451 + getColL16 :: GHC.Prim.Addr# + {- HasNoCafRefs, Unfolding: ("error"#) -} +ff1980320d786af053c918c56beea394 + getColL17 :: [GHC.Types.Char] + {- HasNoCafRefs, Strictness: m2, + Unfolding: (GHC.Types.: + @ GHC.Types.Char + GHC.Show.$fShow(,)2 + (GHC.Types.[] @ GHC.Types.Char)) -} +79518a96650d201c5f67e67a4db3cb67 + getColL2 :: GHC.Prim.Addr# + {- HasNoCafRefs, Unfolding: ("getElem: Trying to get the "#) -} +5619add454821844124a1652165aec69 + getColL3 :: GHC.Stack.Types.CallStack + {- Strictness: m2, + Unfolding: (GHC.Stack.Types.PushCallStack + Main.getColL15 + Main.getColL4 + GHC.Stack.Types.EmptyCallStack) -} +eeb651480663ce22e6859c5904879429 + getColL4 :: GHC.Stack.Types.SrcLoc + {- Strictness: m, + Unfolding: (GHC.Stack.Types.SrcLoc + Main.getColL13 + Main.getColL11 + Main.getColL9 + Main.getColL8 + Main.getColL7 + Main.getColL6 + Main.getColL5) -} +de832c74ff8c2a95f2e64d0ce59ab379 + getColL5 :: GHC.Types.Int + {- HasNoCafRefs, Strictness: m, Unfolding: (GHC.Types.I# 22#) -} +6cbddb6b2bd4ca54512efe418fc3f972 + getColL6 :: GHC.Types.Int + {- HasNoCafRefs, Strictness: m, Unfolding: (GHC.Types.I# 456#) -} +6ebdb60bb88d05048f3b0d9a4cfa8ea5 + getColL7 :: GHC.Types.Int + {- HasNoCafRefs, Strictness: m, Unfolding: (GHC.Types.I# 6#) -} +fbf781328cfd77e1d9fea86e2f58d3a0 + getColL8 :: GHC.Types.Int + {- HasNoCafRefs, Strictness: m, Unfolding: (GHC.Types.I# 451#) -} +ac6cdea8a10db215e86741010968aa95 + getColL9 :: [GHC.Types.Char] + {- Unfolding: (GHC.CString.unpackCString# Main.getColL10) -} +b2e16ce0be6dfbeea7c4f1ecb6d7439d + getColL_go :: [GHC.Types.Char] -> [GHC.Types.Char] + {- Arity: 1, Strictness: -} +bad58c8bb42255af4a1eef18a97a672a + getDiagL :: + (GHC.Types.Int, GHC.Types.Int) -> Data.Matrix.Matrix a -> [a] + {- Arity: 2, + Strictness: , + Inline: [2], + Unfolding: InlineRule (2, True, False) + (\ @ a + (w1 :: (GHC.Types.Int, GHC.Types.Int)) + (w2 :: Data.Matrix.Matrix a) -> + case w1 of ww { (,) ww1 ww2 -> + case ww1 of ww3 { GHC.Types.I# ww4 -> + Main.$wgetDiagL @ a ww4 ww2 w2 } }) -} +b3250ecc7862688bbb8836fe2305b560 + getRowColDiag :: + (GHC.Types.Int, GHC.Types.Int) + -> Data.Matrix.Matrix a -> [((GHC.Types.Int, GHC.Types.Int), a)] + {- Arity: 2, + Strictness: , + Inline: [2], + Unfolding: InlineRule (2, True, False) + (\ @ a + (w1 :: (GHC.Types.Int, GHC.Types.Int)) + (w2 :: Data.Matrix.Matrix a) -> + case w1 of ww { (,) ww1 ww2 -> + case w2 of ww3 { Data.Matrix.M ww4 ww5 ww6 ww7 ww8 ww9 -> + Main.$wgetRowColDiag @ a ww1 ww2 ww4 ww5 ww6 ww7 ww8 ww9 } }) -} +89c54d6735deee0f2e6f5893b7bb62b3 + getRowL :: GHC.Types.Int -> Data.Matrix.Matrix b -> [b] + {- Arity: 2, Strictness: , + Unfolding: (\ @ b + (r :: GHC.Types.Int) + (b1 :: Data.Matrix.Matrix b) -> + letrec { + go1 :: GHC.Prim.Int# -> [b] {- Arity: 1, Strictness: -} + = \ (x :: GHC.Prim.Int#) -> + GHC.Types.: + @ b + (case b1 of wild { Data.Matrix.M dt dt1 dt2 dt3 dt4 ds -> + case r of wild1 { GHC.Types.I# x1 -> + let { + $j :: b {- Strictness: x -} + = GHC.Err.error + @ 'GHC.Types.LiftedRep + @ b + Main.getColL3 + `cast` + (Sym (GHC.Classes.N:IP[0] + <"callStack">_N _N)) + (GHC.CString.unpackAppendCString# + Main.getColL2 + (let { + z :: [GHC.Types.Char] + = GHC.CString.unpackAppendCString# + Main.getColL1 + (case Data.Matrix.$wsizeStr + dt + (GHC.Types.I# dt1) of ww2 { (#,#) ww3 ww4 -> + Main.getColL_go (GHC.Types.: @ GHC.Types.Char ww3 ww4) }) + } in + letrec { + go2 :: [GHC.Types.Char] -> [GHC.Types.Char] + {- Arity: 1, Strictness: -} + = \ (ds1 :: [GHC.Types.Char]) -> + case ds1 of wild2 { + [] -> z : y ys -> GHC.Types.: @ GHC.Types.Char y (go2 ys) } + } in + go2 + (GHC.Types.: + @ GHC.Types.Char + GHC.Show.$fShow(,)4 + (case GHC.Show.$wshowSignedInt + 0# + x1 + (GHC.Types.: + @ GHC.Types.Char + GHC.Show.showList__1 + (GHC.Show.$fShow(,)_$sgo1 + Main.getColL17 + (\ (w2 :: GHC.Base.String)[OneShot] -> + case GHC.Show.$wshowSignedInt + 0# + x + w2 of ww4 { (#,#) ww5 ww6 -> + GHC.Types.: @ GHC.Types.Char ww5 ww6 }) + (GHC.Types.[] + @ GHC.Show.ShowS))) of ww4 { (#,#) ww5 ww6 -> + GHC.Types.: @ GHC.Types.Char ww5 ww6 })))) + } in + case GHC.Prim.># x1 dt of lwild { + DEFAULT + -> case GHC.Prim.># x dt1 of lwild1 { + DEFAULT + -> case GHC.Prim.<# x1 1# of lwild2 { + DEFAULT + -> case GHC.Prim.<# x 1# of lwild3 { + DEFAULT + -> case ds of wild3 { Data.Vector.Vector dt5 dt6 dt7 -> + case GHC.Prim.indexArray# + @ b + dt7 + (GHC.Prim.-# + (GHC.Prim.+# + dt5 + (GHC.Prim.+# + (GHC.Prim.*# + (GHC.Prim.-# (GHC.Prim.+# x1 dt2) 1#) + dt4) + (GHC.Prim.+# x dt3))) + 1#) of ds2 { Unit# ipv -> + ipv } } + 1# -> $j } + 1# -> $j } + 1# -> $j } + 1# -> $j } } }) + (case x of wild { + DEFAULT -> go1 (GHC.Prim.+# wild 1#) 8# -> GHC.Types.[] @ b }) + } in + go1 1#) -} +2a4c80aa03a4f7ee0eee9342de9b7e08 + initBoard :: Data.Matrix.Matrix Main.Square + {- Strictness: m, + Unfolding: (Data.Matrix.M + @ Main.Square + 8# + 8# + 0# + 0# + 8# + Main.initBoard1) -} +2e11b49545df662a0298b6b61ce33edc + initBoard1 :: Data.Vector.Vector Main.Square + {- Unfolding: (case GHC.Magic.runRW# + @ ('GHC.Types.TupleRep + '[ 'GHC.Types.TupleRep '[], 'GHC.Types.LiftedRep]) + @ (# GHC.Prim.State# GHC.Prim.RealWorld, + Data.Vector.Vector Main.Square #) + Main.initBoard2 of ds1 { (#,#) ipv1 ipv2 -> + ipv2 }) -} +9ac58488e11448bdb0825964d3026604 + initBoard2 :: + GHC.Prim.State# GHC.Prim.RealWorld + -> (# GHC.Prim.State# GHC.Prim.RealWorld, + Data.Vector.Vector Main.Square #) + {- Arity: 1, Strictness: , + Unfolding: (\ (s1 :: GHC.Prim.State# + GHC.Prim.RealWorld)[OneShot] -> + case GHC.Prim.newArray# + @ Main.Square + @ (Control.Monad.Primitive.PrimState + (GHC.ST.ST GHC.Prim.RealWorld)) + 64# + (Data.Vector.Mutable.uninitialised @ Main.Square) + s1 + `cast` + (GHC.Prim.State# + (Sym (Control.Monad.Primitive.D:R:PrimStateST[0] + (Nth:0 + (Nth:2 + (_R + ->_R ((#,#) + <'GHC.Types.TupleRep '[]>_R + <'GHC.Types.LiftedRep>_R + _R + (Sub (Sym (Data.Vector.D:R:MutableVector[0])) _N _N))_R))))))_R of ds1 { (#,#) ipv ipv1 -> + let { + exit :: GHC.Prim.State# GHC.Prim.RealWorld + -> (# GHC.Prim.State# GHC.Prim.RealWorld, + Data.Vector.Vector Main.Square #) + {- Arity: 1, Strictness: -} + = \ (w1 :: GHC.Prim.State# GHC.Prim.RealWorld)[OneShot] -> + let { + exit1 :: GHC.Prim.State# GHC.Prim.RealWorld + -> (# GHC.Prim.State# GHC.Prim.RealWorld, + Data.Vector.Vector Main.Square #) + {- Arity: 1, Strictness: -} + = \ (w2 :: GHC.Prim.State# GHC.Prim.RealWorld)[OneShot] -> + case GHC.Prim.writeArray# + @ (Control.Monad.Primitive.PrimState + (GHC.ST.ST GHC.Prim.RealWorld)) + @ Main.Square + ipv1 + 63# + Main.O + w2 + `cast` + (GHC.Prim.State# + (Sym (Control.Monad.Primitive.D:R:PrimStateST[0] + _N)))_R of s'# { DEFAULT -> + case GHC.Prim.unsafeFreezeArray# + @ (Control.Monad.Primitive.PrimState + (GHC.ST.ST GHC.Prim.RealWorld)) + @ Main.Square + ipv1 + s'# of ds2 { (#,#) ipv2 ipv3 -> + (# ipv2 + `cast` + (GHC.Prim.State# + (Control.Monad.Primitive.D:R:PrimStateST[0] + _N))_R, + Data.Vector.Vector @ Main.Square 0# 64# ipv3 #) } } + } in + letrec { + $wgo3 :: GHC.Prim.Int# + -> GHC.Prim.State# GHC.Prim.RealWorld + -> (# GHC.Prim.State# GHC.Prim.RealWorld, + Data.Vector.Vector Main.Square #) + {- Arity: 2, Strictness: , Inline: [2] -} + = \ (ww :: GHC.Prim.Int#) + (w2 :: GHC.Prim.State# GHC.Prim.RealWorld) -> + case ww of wild { + DEFAULT + -> case GHC.Prim.writeArray# + @ (Control.Monad.Primitive.PrimState + (GHC.ST.ST GHC.Prim.RealWorld)) + @ Main.Square + ipv1 + (GHC.Prim.+# 55# wild) + Main.O + w2 + `cast` + (GHC.Prim.State# + (Sym (Control.Monad.Primitive.D:R:PrimStateST[0] + _N)))_R of s'# { DEFAULT -> + $wgo3 + (GHC.Prim.+# wild 1#) + s'# + `cast` + (GHC.Prim.State# + (Control.Monad.Primitive.D:R:PrimStateST[0] + _N))_R } + 8# -> exit1 w2 } + } in + $wgo3 1# w1 + } in + letrec { + $wgo3 :: GHC.Prim.Int# + -> GHC.Prim.State# GHC.Prim.RealWorld + -> (# GHC.Prim.State# GHC.Prim.RealWorld, + Data.Vector.Vector Main.Square #) + {- Arity: 2, Strictness: , Inline: [2] -} + = \ (ww :: GHC.Prim.Int#) + (w1 :: GHC.Prim.State# GHC.Prim.RealWorld) -> + case ww of wild { + DEFAULT + -> let { + exit1 :: GHC.Prim.State# GHC.Prim.RealWorld + -> (# GHC.Prim.State# GHC.Prim.RealWorld, + Data.Vector.Vector Main.Square #) + {- Arity: 1, Strictness: -} + = \ (w2 :: GHC.Prim.State# GHC.Prim.RealWorld)[OneShot] -> + case GHC.Prim.writeArray# + @ (Control.Monad.Primitive.PrimState + (GHC.ST.ST GHC.Prim.RealWorld)) + @ Main.Square + ipv1 + (GHC.Prim.+# -1# (GHC.Prim.*# 8# wild)) + Main.O + w2 + `cast` + (GHC.Prim.State# + (Sym (Control.Monad.Primitive.D:R:PrimStateST[0] + _N)))_R of s'# { DEFAULT -> + $wgo3 + (GHC.Prim.+# wild 1#) + s'# + `cast` + (GHC.Prim.State# + (Control.Monad.Primitive.D:R:PrimStateST[0] + _N))_R } + } in + letrec { + $wgo1 :: GHC.Prim.Int# + -> GHC.Prim.State# GHC.Prim.RealWorld + -> (# GHC.Prim.State# GHC.Prim.RealWorld, + Data.Vector.Vector Main.Square #) + {- Arity: 2, Strictness: , Inline: [2] -} + = \ (ww1 :: GHC.Prim.Int#) + (w2 :: GHC.Prim.State# GHC.Prim.RealWorld) -> + case ww1 of wild1 { + DEFAULT + -> case GHC.Prim.writeArray# + @ (Control.Monad.Primitive.PrimState + (GHC.ST.ST GHC.Prim.RealWorld)) + @ Main.Square + ipv1 + (GHC.Prim.+# + -9# + (GHC.Prim.+# wild1 (GHC.Prim.*# 8# wild))) + Main.O + w2 + `cast` + (GHC.Prim.State# + (Sym (Control.Monad.Primitive.D:R:PrimStateST[0] + _N)))_R of s'# { DEFAULT -> + $wgo1 + (GHC.Prim.+# wild1 1#) + s'# + `cast` + (GHC.Prim.State# + (Control.Monad.Primitive.D:R:PrimStateST[0] + _N))_R } + 8# -> exit1 w2 } + } in + $wgo1 1# w1 + 8# -> exit w1 } + } in + $wgo3 + 1# + ipv + `cast` + (GHC.Prim.State# + (Control.Monad.Primitive.D:R:PrimStateST[0] + _N))_R }) -} +419b12158f8179bd4e20ff85d2021536 + isWinnable :: + GHC.Types.Int -> Data.Matrix.Matrix Main.Square -> GHC.Types.Bool + {- Arity: 2, Strictness: , + Inline: [2], + Unfolding: InlineRule (2, True, False) + (\ (w1 :: GHC.Types.Int) (w2 :: Data.Matrix.Matrix Main.Square) -> + case w1 of ww { GHC.Types.I# ww1 -> Main.$wisWinnable ww1 w2 }) -} +db1e2e2978dca671b96a5fb06e38a355 + isWinnable' :: + p -> Data.Matrix.Matrix Main.Square -> [GHC.Types.Char] + {- Arity: 2, Strictness: , + Inline: [2], + Unfolding: InlineRule (2, True, True) + (\ @ p (w1 :: p) (w2 :: Data.Matrix.Matrix Main.Square) -> + Main.$wisWinnable' @ p w2) -} +fe5821aa57b843ac278ee5301d522efa + isWinnable'1 :: GHC.Prim.Addr# + {- HasNoCafRefs, Unfolding: (" | cs: "#) -} +57dbea7ccb37666dfb68fcfa3dff9762 + isWinnable'2 :: GHC.Prim.Addr# + {- HasNoCafRefs, Unfolding: ("rs: "#) -} +71761c5fe498240bc954dabe79b454e6 + isWinnable1 :: [GHC.Types.Int] + {- Unfolding: (GHC.Enum.eftInt 1# 8#) -} +467cbfe928e10131bc536f2ce6cf6555 + lo1 :: GHC.Integer.Type.Integer + {- HasNoCafRefs, Unfolding: (8) -} +0443aef89f06e494b8dfadf33d9b611e + lo2 :: GHC.Integer.Type.Integer + {- HasNoCafRefs, Unfolding: (0) -} +0adafc7a5420e905b14b79259f36d2e1 + lo8 :: [GHC.Integer.Type.Integer] + {- Unfolding: (GHC.Enum.enumDeltaToInteger1 Main.lo2 Main.lo1) -} +ffd93c9b62998844891c6b51af4852f6 + main :: GHC.Types.IO () + {- Arity: 1, + Unfolding: (GHC.IO.Handle.Text.hPutStr' + GHC.IO.Handle.FD.stdout + Main.main1 + GHC.Types.True) -} +b44f955f71899d698edc98e351205550 + main1 :: [GHC.Types.Char] + {- Unfolding: (GHC.CString.unpackCString# Main.main2) -} +53f8d0c8d47323120ec6d4f5391ba8c2 + main2 :: GHC.Prim.Addr# + {- HasNoCafRefs, Unfolding: ("Hi"#) -} +2c40f682ff1df8a53498b11b24c5d251 + main3 :: + GHC.Prim.State# GHC.Prim.RealWorld + -> (# GHC.Prim.State# GHC.Prim.RealWorld, () #) + {- Arity: 1, + Unfolding: (GHC.TopHandler.runMainIO1 @ () Main.main) -} +2d937b3fb3901c9c5d6305d505827f2c + mapDiag :: + ((GHC.Types.Int, GHC.Types.Int) -> a -> a) + -> (GHC.Types.Int, GHC.Types.Int) + -> Data.Matrix.Matrix a + -> Data.Matrix.Matrix a + {- Arity: 3, + Strictness: m, + Inline: [2], + Unfolding: InlineRule (3, True, False) + (\ @ a + (w1 :: (GHC.Types.Int, GHC.Types.Int) -> a -> a) + (w2 :: (GHC.Types.Int, GHC.Types.Int)) + (w3 :: Data.Matrix.Matrix a) -> + case w3 of ww { Data.Matrix.M ww1 ww2 ww3 ww4 ww5 ww6 -> + case Main.$wmapDiag + @ a + w1 + w2 + ww1 + ww2 + ww3 + ww4 + ww5 + ww6 of ww7 { (#,,,,,#) ww8 ww9 ww10 ww11 ww12 ww13 -> + Data.Matrix.M @ a ww8 ww9 ww10 ww11 ww12 ww13 } }) -} +a2bd0b58bc5bd047e61382be16fefa00 + mapQueensPath :: + ((GHC.Types.Int, GHC.Types.Int) -> a -> a) + -> (GHC.Types.Int, GHC.Types.Int) + -> Data.Matrix.Matrix a + -> Data.Matrix.Matrix a + {- Arity: 3, + Strictness: m, + Unfolding: InlineRule (0, True, True) Main.mapRowColDiag -} +dde1889dbbf5fb38f0e445cb95f5a9de + mapRowColDiag :: + ((GHC.Types.Int, GHC.Types.Int) -> a -> a) + -> (GHC.Types.Int, GHC.Types.Int) + -> Data.Matrix.Matrix a + -> Data.Matrix.Matrix a + {- Arity: 3, + Strictness: m, + Inline: [2], + Unfolding: InlineRule (3, True, False) + (\ @ a + (w1 :: (GHC.Types.Int, GHC.Types.Int) -> a -> a) + (w2 :: (GHC.Types.Int, GHC.Types.Int)) + (w3 :: Data.Matrix.Matrix a) -> + case w2 of ww { (,) ww1 ww2 -> + case w3 of ww3 { Data.Matrix.M ww4 ww5 ww6 ww7 ww8 ww9 -> + case Main.$wmapRowColDiag + @ a + w1 + ww1 + ww2 + ww4 + ww5 + ww6 + ww7 + ww8 + ww9 of ww10 { (#,,,,,#) ww11 ww12 ww13 ww14 ww15 ww16 -> + Data.Matrix.M @ a ww11 ww12 ww13 ww14 ww15 ww16 } } }) -} +3943af003e5304a56a545bd865552127 + markX :: + (GHC.Types.Int, GHC.Types.Int) + -> Data.Matrix.Matrix Main.Square -> Data.Matrix.Matrix Main.Square + {- Arity: 2, + Strictness: m, + Inline: [2], + Unfolding: InlineRule (2, True, False) + (\ (w1 :: (GHC.Types.Int, GHC.Types.Int)) + (w2 :: Data.Matrix.Matrix Main.Square) -> + case w2 of ww { Data.Matrix.M ww1 ww2 ww3 ww4 ww5 ww6 -> + case Main.$wmarkX + w1 + ww1 + ww2 + ww3 + ww4 + ww5 + ww6 of ww7 { (#,,,,,#) ww8 ww9 ww10 ww11 ww12 ww13 -> + Data.Matrix.M @ Main.Square ww8 ww9 ww10 ww11 ww12 ww13 } }) -} +ccc5982bcd77bdad61f876f8d47c5d65 + markX1 :: GHC.Prim.Int# -> GHC.Prim.Int# -> GHC.ST.ST s () + {- Arity: 2, Strictness: x -} +fbac9f9d7dbb4ee97cbb457aa87ce63d + markX2 :: + GHC.Prim.Int# + -> GHC.ST.ST + GHC.Prim.RealWorld + (Data.Vector.Generic.Base.Mutable + Data.Vector.Vector + (Control.Monad.Primitive.PrimState (GHC.ST.ST GHC.Prim.RealWorld)) + Main.Square) + {- Arity: 1, Strictness: x -} +6f1bb09ac67d2a25f7bab55f41ed00c2 + nextAvail :: + Data.Matrix.Matrix Main.Square -> (GHC.Types.Int, GHC.Types.Int) + {- Arity: 1, Strictness: m, + Inline: [2], + Unfolding: InlineRule (1, True, False) + (\ (w1 :: Data.Matrix.Matrix Main.Square) -> + case w1 of ww { Data.Matrix.M ww1 ww2 ww3 ww4 ww5 ww6 -> + Main.$wnextAvail ww1 ww2 ww3 ww4 ww5 ww6 }) -} +90afd4aefbf3357e19db3aabe3af6a43 + nextAvail1 :: + GHC.Prim.Int# + -> GHC.Types.Int -> GHC.Prim.Int# -> GHC.Prim.Int# -> Main.Square + {- Arity: 4, Strictness: x -} +a26d623557216e1e594771f61834fea6 + nextAvail_$sscanBoard :: + Main.Square + -> Data.Matrix.Matrix Main.Square + -> [(GHC.Types.Int, GHC.Types.Int)] + {- Arity: 2, Strictness: , + Unfolding: (\ (s1 :: Main.Square) + (b :: Data.Matrix.Matrix Main.Square) -> + letrec { + go1 :: [(GHC.Types.Int, GHC.Types.Int)] + -> [(GHC.Types.Int, GHC.Types.Int)] + {- Arity: 1, Strictness: -} + = \ (ds :: [(GHC.Types.Int, GHC.Types.Int)]) -> + case ds of wild { + [] -> GHC.Types.[] @ (GHC.Types.Int, GHC.Types.Int) + : y ys + -> case y of wild1 { (,) i j -> + case b of wild2 { Data.Matrix.M dt dt1 dt2 dt3 dt4 ds1 -> + case i of wild3 { GHC.Types.I# x -> + case GHC.Prim.># x dt of lwild { + DEFAULT + -> case j of wild4 { GHC.Types.I# x1 -> + case GHC.Prim.># x1 dt1 of lwild1 { + DEFAULT + -> case GHC.Prim.<# x 1# of lwild2 { + DEFAULT + -> case GHC.Prim.<# x1 1# of lwild3 { + DEFAULT + -> case ds1 of wild5 { Data.Vector.Vector dt5 dt6 dt7 -> + case GHC.Prim.indexArray# + @ Main.Square + dt7 + (GHC.Prim.-# + (GHC.Prim.+# + dt5 + (GHC.Prim.+# + (GHC.Prim.*# + (GHC.Prim.-# + (GHC.Prim.+# x dt2) + 1#) + dt4) + (GHC.Prim.+# x1 dt3))) + 1#) of ds2 { Unit# ipv -> + case ipv of wild6 { + Main.X + -> case s1 of wild7 { + DEFAULT -> go1 ys + Main.X + -> GHC.Types.: + @ (GHC.Types.Int, GHC.Types.Int) + wild1 + (go1 ys) } + Main.Qu + -> case s1 of wild7 { + DEFAULT -> go1 ys + Main.Qu + -> GHC.Types.: + @ (GHC.Types.Int, GHC.Types.Int) + wild1 + (go1 ys) } + Main.O + -> case s1 of wild7 { + DEFAULT -> go1 ys + Main.O + -> GHC.Types.: + @ (GHC.Types.Int, GHC.Types.Int) + wild1 + (go1 ys) } + Main.T + -> case s1 of wild7 { + DEFAULT -> go1 ys + Main.T + -> GHC.Types.: + @ (GHC.Types.Int, GHC.Types.Int) + wild1 + (go1 ys) } } } } + 1# + -> case Main.nextAvail1 x wild4 dt dt1 + ret_ty [(GHC.Types.Int, GHC.Types.Int)] + of {} } + 1# + -> case Main.nextAvail1 x wild4 dt dt1 + ret_ty [(GHC.Types.Int, GHC.Types.Int)] + of {} } + 1# + -> case Main.nextAvail1 x wild4 dt dt1 + ret_ty [(GHC.Types.Int, GHC.Types.Int)] + of {} } } + 1# + -> case Main.nextAvail1 x j dt dt1 + ret_ty [(GHC.Types.Int, GHC.Types.Int)] + of {} } } } } } + } in + go1 Main.allPositions) -} +9b22cd0f7cfb9cd8b86e53ed152db98f + nextOpen :: p -> a + {- Arity: 1, Strictness: x, + Unfolding: InlineRule (1, True, True) + (\ @ p @ a (board :: p) -> + GHC.Err.undefined + @ 'GHC.Types.LiftedRep + @ a + Main.nextOpen1 + `cast` + (Sym (GHC.Classes.N:IP[0] + <"callStack">_N _N))) -} +450959e15bf14abeeae70c90d6596591 + nextOpen1 :: GHC.Stack.Types.CallStack + {- Strictness: m2, + Unfolding: (GHC.Stack.Types.PushCallStack + Main.nextOpen10 + Main.nextOpen2 + GHC.Stack.Types.EmptyCallStack) -} +5492e46593435c9a8973ddd52706b901 + nextOpen10 :: [GHC.Types.Char] + {- Unfolding: (GHC.CString.unpackCString# Main.nextOpen11) -} +34b8814fdedc12dbe175ff398d732cc2 + nextOpen11 :: GHC.Prim.Addr# + {- HasNoCafRefs, Unfolding: ("undefined"#) -} +a81645774aa6aa0b43d03ce34ef4c86a + nextOpen2 :: GHC.Stack.Types.SrcLoc + {- Strictness: m, + Unfolding: (GHC.Stack.Types.SrcLoc + Main.nextOpen9 + Main.nextOpen8 + Main.nextOpen6 + Main.nextOpen5 + Main.nextOpen4 + Main.nextOpen5 + Main.nextOpen3) -} +37396b724a9489f0796e02e1242a57cc + nextOpen3 :: GHC.Types.Int + {- HasNoCafRefs, Strictness: m, Unfolding: (GHC.Types.I# 27#) -} +5039b2582c970c303d6ee00f1c72dc6f + nextOpen4 :: GHC.Types.Int + {- HasNoCafRefs, Strictness: m, Unfolding: (GHC.Types.I# 18#) -} +d043f6099eb02d490a19ed2603a147cd + nextOpen5 :: GHC.Types.Int + {- HasNoCafRefs, Strictness: m, Unfolding: (GHC.Types.I# 342#) -} +8bc53bd5eeee20b8c206a89fe19f2abc + nextOpen6 :: [GHC.Types.Char] + {- Unfolding: (GHC.CString.unpackCString# Main.nextOpen7) -} +28b6eb018de3ac0765c6732596651e21 + nextOpen7 :: GHC.Prim.Addr# + {- HasNoCafRefs, Unfolding: ("src/Main.hs"#) -} +5dd9ebfbcdd27071fb3e5331918a8ed9 + nextOpen8 :: [GHC.Types.Char] + {- Unfolding: (GHC.CString.unpackCString# Main.$trModule2) -} +3ec743b2d53b5b2446ef227872aec674 + nextOpen9 :: [GHC.Types.Char] + {- Unfolding: (GHC.CString.unpackCString# Main.$trModule4) -} +b1f6f256d4e82d1580367898de062da9 + onBoard :: t1 -> (t1 -> t2) -> t2 + {- Arity: 2, HasNoCafRefs, Strictness: , + Unfolding: InlineRule (2, True, True) + (\ @ t @ t1 (b :: t) (f :: t -> t1) -> f b) -} +17b16fcc71d1f9f19009053f733f93b0 + openPositions :: + Data.Matrix.Matrix Main.Square -> [(GHC.Types.Int, GHC.Types.Int)] + {- Arity: 1, Strictness: , + Unfolding: InlineRule (1, True, False) + (\ (b :: Data.Matrix.Matrix Main.Square) -> + Main.nextAvail_$sscanBoard Main.O b) -} +2f3c3f4fd9297ce38b2338795b8625fa + ops :: + [(GHC.Integer.Type.Integer -> GHC.Integer.Type.Integer, + GHC.Integer.Type.Integer -> GHC.Integer.Type.Integer)] + {- Strictness: m2, + Unfolding: (GHC.Types.: + @ (GHC.Integer.Type.Integer -> GHC.Integer.Type.Integer, + GHC.Integer.Type.Integer -> GHC.Integer.Type.Integer) + Main.ops8 + Main.ops1) -} +914d1c5f1d08a2df33b0758b8b1cbe4f + ops1 :: + [(GHC.Integer.Type.Integer -> GHC.Integer.Type.Integer, + GHC.Integer.Type.Integer -> GHC.Integer.Type.Integer)] + {- Strictness: m2, + Unfolding: (GHC.Types.: + @ (GHC.Integer.Type.Integer -> GHC.Integer.Type.Integer, + GHC.Integer.Type.Integer -> GHC.Integer.Type.Integer) + Main.ops7 + Main.ops2) -} +c483f6d1360d80e682071a7fada76a2d + ops2 :: + [(GHC.Integer.Type.Integer -> GHC.Integer.Type.Integer, + GHC.Integer.Type.Integer -> GHC.Integer.Type.Integer)] + {- Strictness: m2, + Unfolding: (GHC.Types.: + @ (GHC.Integer.Type.Integer -> GHC.Integer.Type.Integer, + GHC.Integer.Type.Integer -> GHC.Integer.Type.Integer) + Main.ops6 + Main.ops3) -} +e2bf2566ee0d78e121b68669d2a45b5a + ops3 :: + [(GHC.Integer.Type.Integer -> GHC.Integer.Type.Integer, + GHC.Integer.Type.Integer -> GHC.Integer.Type.Integer)] + {- Strictness: m2, + Unfolding: (GHC.Types.: + @ (GHC.Integer.Type.Integer -> GHC.Integer.Type.Integer, + GHC.Integer.Type.Integer -> GHC.Integer.Type.Integer) + Main.ops4 + (GHC.Types.[] + @ (GHC.Integer.Type.Integer -> GHC.Integer.Type.Integer, + GHC.Integer.Type.Integer -> GHC.Integer.Type.Integer))) -} +4fc14e12c3c545bccf354dfd328363ef + ops4 :: + (GHC.Integer.Type.Integer -> GHC.Integer.Type.Integer, + GHC.Integer.Type.Integer -> GHC.Integer.Type.Integer) + {- Strictness: m, Unfolding: ((Main.ops_b, Main.ops_b)) -} +af67511cc9af72bbbf64830e0e5f2972 + ops5 :: GHC.Integer.Type.Integer + {- HasNoCafRefs, Unfolding: (1) -} +4d05bf6b8d38e4924dbd1cd6fe91b988 + ops6 :: + (GHC.Integer.Type.Integer -> GHC.Integer.Type.Integer, + GHC.Integer.Type.Integer -> GHC.Integer.Type.Integer) + {- Strictness: m, Unfolding: ((Main.ops_b, Main.ops_a)) -} +c8c7d7c9f7f07dc27b1d7488f2d275c4 + ops7 :: + (GHC.Integer.Type.Integer -> GHC.Integer.Type.Integer, + GHC.Integer.Type.Integer -> GHC.Integer.Type.Integer) + {- Strictness: m, Unfolding: ((Main.ops_a, Main.ops_b)) -} +659cc3ca049e6155e4c40a7665798164 + ops8 :: + (GHC.Integer.Type.Integer -> GHC.Integer.Type.Integer, + GHC.Integer.Type.Integer -> GHC.Integer.Type.Integer) + {- Strictness: m, Unfolding: ((Main.ops_a, Main.ops_a)) -} +230c5a60ddf52a851259b0f5fb0b5a02 + ops_a :: GHC.Integer.Type.Integer -> GHC.Integer.Type.Integer + {- Arity: 1, Strictness: , + Unfolding: InlineRule (1, True, False) + (\ (ds :: GHC.Integer.Type.Integer) -> + GHC.Integer.Type.plusInteger ds Main.ops5) -} +0977965361a29e006d3b014e5d47953c + ops_b :: GHC.Integer.Type.Integer -> GHC.Integer.Type.Integer + {- Arity: 1, Unfolding: (Main.$ssubtract1 Main.ops5) -} +fa63260e1ced6c325a6fea254285a86e + placeQueen :: + (GHC.Types.Int, GHC.Types.Int) + -> Data.Matrix.Matrix Main.Square -> Data.Matrix.Matrix Main.Square + {- Arity: 2, + Strictness: m, + Inline: [2], + Unfolding: InlineRule (2, True, False) + (\ (w1 :: (GHC.Types.Int, GHC.Types.Int)) + (w2 :: Data.Matrix.Matrix Main.Square) -> + case w1 of ww { (,) ww1 ww2 -> + case w2 of ww3 { Data.Matrix.M ww4 ww5 ww6 ww7 ww8 ww9 -> + case Main.$wplaceQueen + ww1 + ww2 + ww4 + ww5 + ww6 + ww7 + ww8 + ww9 of ww10 { (#,,,,,#) ww11 ww12 ww13 ww14 ww15 ww16 -> + Data.Matrix.M @ Main.Square ww11 ww12 ww13 ww14 ww15 ww16 } } }) -} +a1f12d5025f58ce56d4a5a7bc26dc092 + placeQueen' :: + (GHC.Types.Int, GHC.Types.Int) + -> Data.Matrix.Matrix Main.Square -> Data.Matrix.Matrix Main.Square + {- Arity: 2, + Strictness: m, + Inline: [2], + Unfolding: InlineRule (2, True, False) + (\ (w1 :: (GHC.Types.Int, GHC.Types.Int)) + (w2 :: Data.Matrix.Matrix Main.Square) -> + case w1 of ww { (,) ww1 ww2 -> + case w2 of ww3 { Data.Matrix.M ww4 ww5 ww6 ww7 ww8 ww9 -> + case Main.$wplaceQueen' + ww1 + ww2 + ww4 + ww5 + ww6 + ww7 + ww8 + ww9 of ww10 { (#,,,,,#) ww11 ww12 ww13 ww14 ww15 ww16 -> + Data.Matrix.M @ Main.Square ww11 ww12 ww13 ww14 ww15 ww16 } } }) -} +dc257c873b9f55af4a5cae0dd796842c + placeQueen'_fX :: p1 -> p2 -> Main.Square + {- Arity: 2, HasNoCafRefs, Strictness: , + Unfolding: InlineRule (2, True, True) + (\ @ p @ p1 (ds :: p) (x :: p1) -> Main.X) -} +5867a72be54a53ffdbc791900449f7cf + placeQueen1 :: + (GHC.Types.Int, GHC.Types.Int) -> Main.Square -> Main.Square + {- Arity: 2, HasNoCafRefs, Strictness: , + Unfolding: InlineRule (2, True, True) + (\ (ds :: (GHC.Types.Int, GHC.Types.Int)) (ds1 :: Main.Square) -> + Main.X) -} +6e29c0608e46d228d79be61c7b198415 + queenAllowed :: + (GHC.Types.Int, GHC.Types.Int) + -> Data.Matrix.Matrix Main.Square -> GHC.Types.Bool + {- Arity: 2, + Strictness: , + Unfolding: InlineRule (0, True, True) + Main.queenAllowed1 + `cast` + (<(GHC.Types.Int, GHC.Types.Int)>_R + ->_R _R + ->_R Data.Semigroup.Internal.N:All[0]) -} +78aa727ec6070d1a0a93c445c121ee95 + queenAllowed1 :: + (GHC.Types.Int, GHC.Types.Int) + -> Data.Matrix.Matrix Main.Square -> Data.Semigroup.Internal.All + {- Arity: 2, + Strictness: , + Unfolding: InlineRule (2, True, False) + (\ (p :: (GHC.Types.Int, GHC.Types.Int)) + (b :: Data.Matrix.Matrix Main.Square) -> + letrec { + go1 :: [((GHC.Types.Int, GHC.Types.Int), Main.Square)] + -> Data.Semigroup.Internal.All + {- Arity: 1 -} + = \ (ds :: [((GHC.Types.Int, GHC.Types.Int), Main.Square)]) -> + case ds of wild { + [] + -> GHC.Types.True `cast` (Sym (Data.Semigroup.Internal.N:All[0])) + : y ys + -> case y of wild1 { (,) ds1 y1 -> + case y1 of wild2 { + DEFAULT + -> GHC.Types.False `cast` (Sym (Data.Semigroup.Internal.N:All[0])) + Main.O -> go1 ys } } } + } in + go1 (Main.getRowColDiag @ Main.Square p b)) -} +ac3e1db14fd14a5e30c664cab50d0fee + s :: + Data.Matrix.Matrix Main.Square -> [Data.Matrix.Matrix Main.Square] + {- Arity: 1, Strictness: , + Unfolding: (\ (b :: Data.Matrix.Matrix Main.Square) -> + letrec { + go1 :: [(GHC.Types.Int, GHC.Types.Int)] + -> [Data.Matrix.Matrix Main.Square] + {- Arity: 1, Strictness: -} + = \ (ds :: [(GHC.Types.Int, GHC.Types.Int)]) -> + case ds of wild { + [] -> GHC.Types.[] @ (Data.Matrix.Matrix Main.Square) + : y ys + -> case y of ww { (,) ww1 ww2 -> + case b of ww3 { Data.Matrix.M ww4 ww5 ww6 ww7 ww8 ww9 -> + let { + exit :: [Data.Matrix.Matrix Main.Square] + = GHC.Types.: + @ (Data.Matrix.Matrix Main.Square) + (case Main.$wplaceQueen + ww1 + ww2 + ww4 + ww5 + ww6 + ww7 + ww8 + ww9 of ww10 { (#,,,,,#) ww11 ww12 ww13 ww14 ww15 ww16 -> + Data.Matrix.M @ Main.Square ww11 ww12 ww13 ww14 ww15 ww16 }) + (go1 ys) + } in + let { + exit1 :: [Data.Matrix.Matrix Main.Square] = go1 ys + } in + letrec { + go2 :: [((GHC.Types.Int, GHC.Types.Int), Main.Square)] + -> [Data.Matrix.Matrix Main.Square] + {- Arity: 1, Strictness: -} + = \ (ds1 :: [((GHC.Types.Int, GHC.Types.Int), Main.Square)]) -> + case ds1 of wild1 { + [] -> exit + : y1 ys1 + -> case y1 of wild2 { (,) ds2 y2 -> + case y2 of wild3 { DEFAULT -> exit1 Main.O -> go2 ys1 } } } + } in + go2 + (Main.$wgetRowColDiag + @ Main.Square + ww1 + ww2 + ww4 + ww5 + ww6 + ww7 + ww8 + ww9) } } } + } in + go1 (Main.nextAvail_$sscanBoard Main.O b)) -} +136bbc6ab363482125bcf62d8afaf976 + scanBoard :: + GHC.Classes.Eq a => + a -> Data.Matrix.Matrix a -> [(GHC.Types.Int, GHC.Types.Int)] + {- Arity: 3, + Strictness: , + Unfolding: (\ @ a + ($dEq :: GHC.Classes.Eq a) + (s1 :: a) + (b :: Data.Matrix.Matrix a) -> + letrec { + go1 :: [(GHC.Types.Int, GHC.Types.Int)] + -> [(GHC.Types.Int, GHC.Types.Int)] + {- Arity: 1, Strictness: -} + = \ (ds :: [(GHC.Types.Int, GHC.Types.Int)]) -> + case ds of wild { + [] -> GHC.Types.[] @ (GHC.Types.Int, GHC.Types.Int) + : y ys + -> case y of wild1 { (,) i j -> + case GHC.Classes.== + @ a + $dEq + (case b of wild2 { Data.Matrix.M dt dt1 dt2 dt3 dt4 ds1 -> + case i of wild3 { GHC.Types.I# x -> + let { + $j :: a {- Strictness: x -} + = GHC.Err.error + @ 'GHC.Types.LiftedRep + @ a + Main.getColL3 + `cast` + (Sym (GHC.Classes.N:IP[0] + <"callStack">_N _N)) + (GHC.CString.unpackAppendCString# + Main.getColL2 + (GHC.Base.++_$s++ + @ GHC.Types.Char + (GHC.CString.unpackAppendCString# + Main.getColL1 + (case Data.Matrix.$wsizeStr + dt + (GHC.Types.I# + dt1) of ww2 { (#,#) ww3 ww4 -> + GHC.Base.++_$s++ + @ GHC.Types.Char + Main.scanBoard_z + ww3 + ww4 })) + GHC.Show.$fShow(,)4 + (case GHC.Show.$wshowSignedInt + 0# + x + (GHC.Types.: + @ GHC.Types.Char + GHC.Show.showList__1 + (GHC.Show.$fShow(,)_$sgo1 + Main.getColL17 + (\ (w2 :: GHC.Base.String)[OneShot] -> + case j of ww2 { GHC.Types.I# ww3 -> + case GHC.Show.$wshowSignedInt + 0# + ww3 + w2 of ww4 { (#,#) ww5 ww6 -> + GHC.Types.: + @ GHC.Types.Char + ww5 + ww6 } }) + (GHC.Types.[] + @ GHC.Show.ShowS))) of ww4 { (#,#) ww5 ww6 -> + GHC.Types.: @ GHC.Types.Char ww5 ww6 }))) + } in + case GHC.Prim.># x dt of lwild { + DEFAULT + -> case j of wild4 { GHC.Types.I# x1 -> + case GHC.Prim.># x1 dt1 of lwild1 { + DEFAULT + -> case GHC.Prim.<# x 1# of lwild2 { + DEFAULT + -> case GHC.Prim.<# x1 1# of lwild3 { + DEFAULT + -> case ds1 of wild5 { Data.Vector.Vector dt5 dt6 dt7 -> + case GHC.Prim.indexArray# + @ a + dt7 + (GHC.Prim.-# + (GHC.Prim.+# + dt5 + (GHC.Prim.+# + (GHC.Prim.*# + (GHC.Prim.-# + (GHC.Prim.+# x dt2) + 1#) + dt4) + (GHC.Prim.+# x1 dt3))) + 1#) of ds2 { Unit# ipv -> + ipv } } + 1# -> $j } + 1# -> $j } + 1# -> $j } } + 1# -> $j } } }) + s1 of wild2 { + GHC.Types.False -> go1 ys + GHC.Types.True + -> GHC.Types.: + @ (GHC.Types.Int, GHC.Types.Int) + wild1 + (go1 ys) } } } + } in + go1 Main.allPositions) -} +ba4d206db78a5cdc12cbc5213b6efa45 + scanBoard1 :: GHC.Prim.Addr# + {- HasNoCafRefs, Unfolding: (" matrix."#) -} +dd473e64c7fd49868fbead83c5d37d7c + scanBoard_z :: [GHC.Types.Char] + {- Unfolding: (GHC.CString.unpackCString# Main.scanBoard1) -} +730d75bde90b9d85a238ada997a4cedb + solve :: + (GHC.Classes.Ord t, GHC.Num.Num t) => + t -> [Data.Matrix.Matrix Main.Square] + {- Arity: 3, + Strictness: , + Inline: [2], + Unfolding: InlineRule (3, True, False) + (\ @ t (w1 :: GHC.Classes.Ord t) (w2 :: GHC.Num.Num t) (w3 :: t) -> + case w1 of ww { GHC.Classes.C:Ord ww1 ww2 ww3 ww4 ww5 ww6 ww7 ww8 -> + Main.$wsolve @ t ww1 ww3 ww5 w2 w3 }) -} +bf34852c4989cdd534e45ed8798f1cc1 + solve1 :: [Data.Matrix.Matrix Main.Square] + {- Unfolding: (GHC.Base.++ + @ (Data.Matrix.Matrix Main.Square) + (Main.solve2 Main.initBoard) + (GHC.Types.[] @ (Data.Matrix.Matrix Main.Square))) -} +e1e9b7845f8b9b9dd2f50c649384dcaf + solve2 :: + Data.Matrix.Matrix Main.Square -> [Data.Matrix.Matrix Main.Square] + {- Arity: 1, Strictness: , + Unfolding: (\ (b :: Data.Matrix.Matrix Main.Square) -> + GHC.Base.map + @ (GHC.Types.Int, GHC.Types.Int) + @ (Data.Matrix.Matrix Main.Square) + (\ (p :: (GHC.Types.Int, GHC.Types.Int)) -> Main.placeQueen p b) + (Main.nextAvail_$sscanBoard Main.O b)) -} +c184a666bff831ddddecc4b865dff3df + solve_go :: + [Data.Matrix.Matrix Main.Square] + -> [Data.Matrix.Matrix Main.Square] + {- Arity: 1, Strictness: -} +7a7a57dbb9af5196c25058ab4a74fa7b + w :: [Data.Matrix.Matrix Main.Square] + {- Unfolding: (Main.$wwinners' + @ GHC.Integer.Type.Integer + Main.initBoard) -} +4574f1ee92f6f2d180c8f1d8da82d147 + winnable :: a + {- Strictness: x -} +a4252cdb991d662ac35e424364aba1a6 + winners :: + (GHC.Classes.Eq p, GHC.Num.Num p) => + p + -> [Data.Matrix.Matrix Main.Square] + -> [Data.Matrix.Matrix Main.Square] + {- Arity: 4, + Strictness: , + Inline: [2], + Unfolding: InlineRule (4, True, False) + (\ @ p + (w1 :: GHC.Classes.Eq p) + (w2 :: GHC.Num.Num p) + (w3 :: p) + (w4 :: [Data.Matrix.Matrix Main.Square]) -> + case w1 of ww { GHC.Classes.C:Eq ww1 ww2 -> + Main.$wwinners @ p ww1 w2 w3 w4 }) -} +3fcc2cf6408df510d613a4b754ea3680 + winners' :: + p + -> Data.Matrix.Matrix Main.Square + -> [Data.Matrix.Matrix Main.Square] + {- Arity: 2, Strictness: , + Inline: [2], + Unfolding: InlineRule (2, True, True) + (\ @ p (w1 :: p) (w2 :: Data.Matrix.Matrix Main.Square) -> + Main.$wwinners' @ p w2) -} +8c043a319c68bd087e5d8643d5ba7d9d + winners1 :: + [Data.Matrix.Matrix Main.Square] + -> [Data.Matrix.Matrix Main.Square] + {- Arity: 1, Strictness: -} +3b9dd7cd56ddb92f4921e9fe96b4dd83 + winners_go :: + [Data.Matrix.Matrix Main.Square] + -> [Data.Matrix.Matrix Main.Square] + {- Arity: 1, Strictness: -} +instance GHC.Classes.Eq [Main.Square] = Main.$fEqSquare +instance GHC.Show.Show [Main.Square] = Main.$fShowSquare +"SPEC scanBoard @ Square" forall ($dEq :: GHC.Classes.Eq + Main.Square) + Main.scanBoard @ Main.Square $dEq = Main.nextAvail_$sscanBoard +"SPEC/Main $fEq(,) @ Int @ Int" [orphan] forall (v1 :: GHC.Classes.Eq + GHC.Types.Int) + (v :: GHC.Classes.Eq GHC.Types.Int) + GHC.Classes.$fEq(,) @ GHC.Types.Int @ GHC.Types.Int v v1 + = Main.$s$fEq(,) +"SPEC/Main $fEq(,)_$c/= @ Int @ Int" [orphan] forall ($dEq1 :: GHC.Classes.Eq + GHC.Types.Int) + ($dEq :: GHC.Classes.Eq GHC.Types.Int) + GHC.Classes.$fEq(,)_$c/= @ GHC.Types.Int @ GHC.Types.Int $dEq $dEq1 + = Main.$s$fEq(,)_$s$fEq(,)_$c/= +"SPEC/Main subtract @ Int" [orphan] forall ($dNum :: GHC.Num.Num + GHC.Types.Int) + GHC.Num.subtract @ GHC.Types.Int $dNum = Main.$ssubtract +"SPEC/Main subtract @ Integer" [orphan] forall ($dNum :: GHC.Num.Num + GHC.Integer.Type.Integer) + GHC.Num.subtract @ GHC.Integer.Type.Integer $dNum + = Main.$ssubtract1 +trusted: none +require own pkg trusted: False +module header: + Nothing +declaration docs: +arg docs: + -- cgit v1.2.3