==================== 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: