Merge branch 'master' of emmy.childrenofmay.org:public_git/8queens

167 files changed, 2 insertions, 10157 deletions

diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..8ee1bf9
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1 @@
+.stack-work
diff --git a/.stack-work/dist/x86_64-linux/Cabal-2.4.0.1/build/8queens/8queens b/.stack-work/dist/x86_64-linux/Cabal-2.4.0.1/build/8queens/8queens
deleted file mode 100755
index 9ca59a9..0000000
--- a/.stack-work/dist/x86_64-linux/Cabal-2.4.0.1/build/8queens/8queens
+++ /dev/null
diff --git a/.stack-work/dist/x86_64-linux/Cabal-2.4.0.1/build/8queens/8queens-tmp/Main.hi b/.stack-work/dist/x86_64-linux/Cabal-2.4.0.1/build/8queens/8queens-tmp/Main.hi
deleted file mode 100644
index 9e3e3a5..0000000
--- a/.stack-work/dist/x86_64-linux/Cabal-2.4.0.1/build/8queens/8queens-tmp/Main.hi
+++ /dev/null
diff --git a/.stack-work/dist/x86_64-linux/Cabal-2.4.0.1/build/8queens/8queens-tmp/Main.o b/.stack-work/dist/x86_64-linux/Cabal-2.4.0.1/build/8queens/8queens-tmp/Main.o
deleted file mode 100644
index 1dadf1b..0000000
--- a/.stack-work/dist/x86_64-linux/Cabal-2.4.0.1/build/8queens/8queens-tmp/Main.o
+++ /dev/null
diff --git a/.stack-work/dist/x86_64-linux/Cabal-2.4.0.1/build/8queens/8queens-tmp/src/Main.dump-hi b/.stack-work/dist/x86_64-linux/Cabal-2.4.0.1/build/8queens/8queens-tmp/src/Main.dump-hi
deleted file mode 100644
index f380580..0000000
--- a/.stack-work/dist/x86_64-linux/Cabal-2.4.0.1/build/8queens/8queens-tmp/src/Main.dump-hi
+++ /dev/null
@@ -1,2517 +0,0 @@
-
-==================== 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: <S,1*U><S,1*U>,
-     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: <S,1*U><S,1*U>,
-     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: <S,1*U>,
-     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: <S,1*U><L,U>,
-     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: <L,A><S,1*U><L,1*U>, 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: <S(S(S)L),1*U(1*U(U),1*U(U))><S(S(S)L),1*U(1*U(U),1*U(U))>,
-     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: <S(S),1*U(U)><S(S),1*U(U)>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: <S,U><S,1*U>, 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: <S,1*U><L,1*U>, 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: <S,U><L,U(U)><L,U(U,U,A,A,A,A)>, 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: <L,C(U(U))><L,C(U(U))>, 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: <S,U><L,1*U(U)>, 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: <L,U(A,A,A,A,A,A,C(U))><L,U(A,A,A,A,A,A,C(C1(U)),A)><L,U(A,A,A,A,A,A,C(U))><C(C(S)),C(C1(U))><L,U><L,U>,
-     Inline: [2] -}
-e7b8a501f5fd9578b49e2b724f683bc8
-  $wgetDiagL ::
-    GHC.Prim.Int# -> GHC.Types.Int -> Data.Matrix.Matrix a -> [a]
-  {- Arity: 3, Strictness: <S,U><L,U(U)><L,U(U,U,U,U,U,U(U,A,U))>,
-     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: <L,U(U)><L,U(U)><L,U><S,U><L,U><L,U><L,U><L,U(U,A,U)>,
-     Inline: [2] -}
-947a5776179f0c1f40c4a8ad30b9fd68
-  $wgo :: [Main.Square] -> GHC.Prim.Int# -> GHC.Types.Int
-  {- Arity: 2, HasNoCafRefs, Strictness: <S,1*U><S,U>m,
-     Inline: [2] -}
-715619f66da8ee3670b7cc69be050c49
-  $wisWinnable ::
-    GHC.Prim.Int# -> Data.Matrix.Matrix Main.Square -> GHC.Types.Bool
-  {- Arity: 2, Strictness: <S,U><L,U(U,U,U,U,U,U(U,A,U))>,
-     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: <L,U(U,U,U,U,U,U(U,A,U))>, 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: <L,C(C1(U))><L,1*U(1*U(U),U(U))><S,U><S,U><L,U><L,U><L,U><L,U(U,A,U)>,
-     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: <L,C(C1(U))><L,U(U)><L,U(U)><S,U><S,U><L,U><L,U><L,U><L,U(U,A,U)>,
-     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: <L,1*U(1*U(U),1*U(U))><S,U><S,U><S,U><S,U><S,U><L,1*U(U,U,U)>,
-     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]
-                                                     <GHC.Prim.RealWorld>_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]
-                                                      <GHC.Prim.RealWorld>_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: <S,U><S,U><S,U><S,U><S,U><L,U(U,A,U)>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)
-                          <join 1> {- Arity: 1, Strictness: <S,1*U>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: <L,U(U)><L,U(U)><S,U><S,U><S,U><S,U><S,U><L,U(U,A,U)>,
-     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]
-                                                     <GHC.Prim.RealWorld>_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]
-                                                      <GHC.Prim.RealWorld>_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: <L,U(U)><L,U(U)><S,U><S,U><S,U><S,U><S,U><L,U(U,A,U)>,
-     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]
-                                                     <GHC.Prim.RealWorld>_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]
-                                                      <GHC.Prim.RealWorld>_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: <L,1*U(C(C1(U)),A)><C(C(S)),1*C1(C1(U))><L,1*C1(C1(U))><L,U(A,C(C1(U)),A,A,A,A,C(U))><L,U>,
-     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: <L,U> -}
-                             = \ (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: <C(C(S)),C(C1(U))><L,U(A,C(C1(U)),A,A,A,A,1*C1(U))><L,U><S,1*U>,
-     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]
-                     <join 2> {- Arity: 2, Strictness: <L,U><S,1*U> -}
-                   = \ (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: <L,U(U,U,U,U,U,U(U,A,U))>, 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: <S,1*U> -}
-                   = \ (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] <join 0>
-                            = 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] <join 0> = go1 ys
-                          } in
-                          letrec {
-                            go2 :: [((GHC.Types.Int, GHC.Types.Int), Main.Square)]
-                                   -> [Data.Matrix.Matrix Main.Square]
-                              <join 1> {- Arity: 1, Strictness: <S,1*U> -}
-                            = \ (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: <L,U> -}
-194ce8b8e7f8d37be79aac8aa28e9d44
-  allops :: b -> b -> [(b, b)]
-  {- Arity: 2, HasNoCafRefs, Strictness: <L,U><L,U>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: <S,1*U(U,U)><S,1*U(1*C1(U),1*C1(U))>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: <L,U(U,U)>,
-     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: <S(S(S)L),1*U(1*U(U),U(U))><L,U(U,U,A,A,A,A)>,
-     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: <L,U(A,A,A,A,A,A,C(U))><L,U(A,A,A,A,A,A,C(C1(U)),A)><L,U(A,A,A,A,A,A,C(U))><S(LLLLLLC(C(S))L),1*U(A,A,A,A,A,A,C(C1(U)),A)><L,U><L,U>,
-     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: <S(S),1*U(U)>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: <L,U(U)><L,U(U,U,U,U,U,U(U,A,U))>,
-     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: <L,U> -}
-                   = \ (x :: GHC.Prim.Int#) ->
-                     GHC.Types.:
-                       @ b
-                       (case b1 of wild { Data.Matrix.M dt dt1 dt2 dt3 dt4 ds ->
-                        let {
-                          $j :: b <join 0> {- Strictness: x -}
-                          = GHC.Err.error
-                              @ 'GHC.Types.LiftedRep
-                              @ b
-                              Main.getColL3
-                                `cast`
-                              (Sym (GHC.Classes.N:IP[0]
-                                        <"callStack">_N <GHC.Stack.Types.CallStack>_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: <S,1*U> -}
-                                    = \ (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: <S,1*U> -}
-bad58c8bb42255af4a1eef18a97a672a
-  getDiagL ::
-    (GHC.Types.Int, GHC.Types.Int) -> Data.Matrix.Matrix a -> [a]
-  {- Arity: 2,
-     Strictness: <S(S(S)L),1*U(1*U(U),U(U))><L,U(U,U,U,U,U,U(U,A,U))>,
-     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: <S,1*U(U(U),U(U))><S(SSSSSL),1*U(U,U,U,U,U,U(U,A,U))>,
-     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: <L,U(U)><L,U(U,U,U,U,U,U(U,A,U))>,
-     Unfolding: (\ @ b
-                   (r :: GHC.Types.Int)
-                   (b1 :: Data.Matrix.Matrix b) ->
-                 letrec {
-                   go1 :: GHC.Prim.Int# -> [b] {- Arity: 1, Strictness: <L,U> -}
-                   = \ (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 <join 0> {- Strictness: x -}
-                          = GHC.Err.error
-                              @ 'GHC.Types.LiftedRep
-                              @ b
-                              Main.getColL3
-                                `cast`
-                              (Sym (GHC.Classes.N:IP[0]
-                                        <"callStack">_N <GHC.Stack.Types.CallStack>_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: <S,1*U> -}
-                                    = \ (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: <S,U>,
-     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
-                                               (<GHC.Prim.State# GHC.Prim.RealWorld>_R
-                                                ->_R ((#,#)
-                                                        <'GHC.Types.TupleRep '[]>_R
-                                                        <'GHC.Types.LiftedRep>_R
-                                                        <GHC.Prim.State# GHC.Prim.RealWorld>_R
-                                                        (Sub (Sym (Data.Vector.D:R:MutableVector[0])) <GHC.Prim.RealWorld>_N <Main.Square>_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 #)
-                     <join 1> {- Arity: 1, Strictness: <S,U> -}
-                   = \ (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 #)
-                         <join 1> {- Arity: 1, Strictness: <S,U> -}
-                       = \ (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]
-                                             <GHC.Prim.RealWorld>_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]
-                                    <GHC.Prim.RealWorld>_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 #)
-                         <join 2> {- Arity: 2, Strictness: <S,1*U><S,U>, 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]
-                                                  <GHC.Prim.RealWorld>_N)))_R of s'# { DEFAULT ->
-                              $wgo3
-                                (GHC.Prim.+# wild 1#)
-                                s'#
-                                  `cast`
-                                (GHC.Prim.State#
-                                   (Control.Monad.Primitive.D:R:PrimStateST[0]
-                                        <GHC.Prim.RealWorld>_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 #)
-                     <join 2> {- Arity: 2, Strictness: <S,1*U><S,U>, 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 #)
-                              <join 1> {- Arity: 1, Strictness: <S,U> -}
-                            = \ (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]
-                                                  <GHC.Prim.RealWorld>_N)))_R of s'# { DEFAULT ->
-                              $wgo3
-                                (GHC.Prim.+# wild 1#)
-                                s'#
-                                  `cast`
-                                (GHC.Prim.State#
-                                   (Control.Monad.Primitive.D:R:PrimStateST[0]
-                                        <GHC.Prim.RealWorld>_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 #)
-                              <join 2> {- Arity: 2, Strictness: <S,1*U><S,U>, 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]
-                                                       <GHC.Prim.RealWorld>_N)))_R of s'# { DEFAULT ->
-                                   $wgo1
-                                     (GHC.Prim.+# wild1 1#)
-                                     s'#
-                                       `cast`
-                                     (GHC.Prim.State#
-                                        (Control.Monad.Primitive.D:R:PrimStateST[0]
-                                             <GHC.Prim.RealWorld>_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]
-                           <GHC.Prim.RealWorld>_N))_R }) -}
-419b12158f8179bd4e20ff85d2021536
-  isWinnable ::
-    GHC.Types.Int -> Data.Matrix.Matrix Main.Square -> GHC.Types.Bool
-  {- Arity: 2, Strictness: <S(S),1*U(U)><L,U(U,U,U,U,U,U(U,A,U))>,
-     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: <L,A><L,U(U,U,U,U,U,U(U,A,U))>,
-     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: <L,C(C1(U))><L,1*U(1*U(U),U(U))><S(SSSSSL),1*U(U,U,U,U,U,U(U,A,U))>m,
-     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: <L,C(C1(U))><S,1*U(U(U),U(U))><S(SSSSSL),1*U(U,U,U,U,U,U(U,A,U))>m,
-     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: <L,C(C1(U))><S,1*U(U(U),U(U))><S(SSSSSL),1*U(U,U,U,U,U,U(U,A,U))>m,
-     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: <L,1*U(1*U(U),1*U(U))><S(SSSSSL),1*U(U,U,U,U,U,1*U(U,U,U))>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: <B,U><B,U>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: <B,U>x -}
-6f1bb09ac67d2a25f7bab55f41ed00c2
-  nextAvail ::
-    Data.Matrix.Matrix Main.Square -> (GHC.Types.Int, GHC.Types.Int)
-  {- Arity: 1, Strictness: <S(SSSSSL),1*U(U,U,U,U,U,U(U,A,U))>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: <B,U><B,1*U(U)><B,U><B,U>x -}
-a26d623557216e1e594771f61834fea6
-  nextAvail_$sscanBoard ::
-    Main.Square
-    -> Data.Matrix.Matrix Main.Square
-    -> [(GHC.Types.Int, GHC.Types.Int)]
-  {- Arity: 2, Strictness: <L,U><L,U(U,U,U,U,U,U(U,A,U))>,
-     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: <S,1*U> -}
-                   = \ (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: <B,A>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 <GHC.Stack.Types.CallStack>_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: <L,U><C(S),1*C1(U)>,
-     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: <L,U(U,U,U,U,U,U(U,A,U))>,
-     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: <S,1*U>,
-     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: <S,1*U(U(U),U(U))><S(SSSSSL),1*U(U,U,U,U,U,U(U,A,U))>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: <S,1*U(U(U),U(U))><S(SSSSSL),1*U(U,U,U,U,U,U(U,A,U))>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: <L,A><L,A>,
-     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: <L,A><L,A>,
-     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: <S,1*U(U(U),U(U))><S(SSSSSL),1*U(U,U,U,U,U,U(U,A,U))>,
-     Unfolding: InlineRule (0, True, True)
-                Main.queenAllowed1
-                  `cast`
-                (<(GHC.Types.Int, GHC.Types.Int)>_R
-                 ->_R <Data.Matrix.Matrix Main.Square>_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: <S,1*U(U(U),U(U))><S(SSSSSL),1*U(U,U,U,U,U,U(U,A,U))>,
-     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
-                     <join 1> {- 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: <L,U(U,U,U,U,U,U(U,A,U))>,
-     Unfolding: (\ (b :: Data.Matrix.Matrix Main.Square) ->
-                 letrec {
-                   go1 :: [(GHC.Types.Int, GHC.Types.Int)]
-                          -> [Data.Matrix.Matrix Main.Square]
-                     {- Arity: 1, Strictness: <S,1*U> -}
-                   = \ (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] <join 0>
-                            = 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] <join 0> = go1 ys
-                          } in
-                          letrec {
-                            go2 :: [((GHC.Types.Int, GHC.Types.Int), Main.Square)]
-                                   -> [Data.Matrix.Matrix Main.Square]
-                              <join 1> {- Arity: 1, Strictness: <S,1*U> -}
-                            = \ (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: <L,U(C(C1(U)),A)><L,U><L,U(U,U,U,U,U,U(U,A,U))>,
-     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: <S,1*U> -}
-                   = \ (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 <join 0> {- Strictness: x -}
-                                    = GHC.Err.error
-                                        @ 'GHC.Types.LiftedRep
-                                        @ a
-                                        Main.getColL3
-                                          `cast`
-                                        (Sym (GHC.Classes.N:IP[0]
-                                                  <"callStack">_N <GHC.Stack.Types.CallStack>_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: <S(LLC(C(S))LLLLL),1*U(1*U(C(C1(U)),A),A,1*C1(C1(U)),A,1*C1(C1(U)),A,A,A)><L,U(A,C(C1(U)),A,A,A,A,C(U))><L,U>,
-     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: <L,U(U,U,U,U,U,U(U,A,U))>,
-     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: <S,1*U> -}
-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: <S(C(C(S))L),1*U(C(C1(U)),A)><L,U(A,C(C1(U)),A,A,A,A,C(U))><L,U><S,1*U>,
-     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: <L,A><L,U(U,U,U,U,U,U(U,A,U))>,
-     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: <S,1*U> -}
-3b9dd7cd56ddb92f4921e9fe96b4dd83
-  winners_go ::
-    [Data.Matrix.Matrix Main.Square]
-    -> [Data.Matrix.Matrix Main.Square]
-  {- Arity: 1, Strictness: <S,1*U> -}
-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:
-
diff --git a/.stack-work/dist/x86_64-linux/Cabal-2.4.0.1/build/8queens/autogen/Paths_8queens.hs b/.stack-work/dist/x86_64-linux/Cabal-2.4.0.1/build/8queens/autogen/Paths_8queens.hs
deleted file mode 100644
index 7e16751..0000000
--- a/.stack-work/dist/x86_64-linux/Cabal-2.4.0.1/build/8queens/autogen/Paths_8queens.hs
+++ /dev/null
@@ -1,50 +0,0 @@
-{-# LANGUAGE CPP #-}
-{-# LANGUAGE NoRebindableSyntax #-}
-{-# OPTIONS_GHC -fno-warn-missing-import-lists #-}
-module Paths_8queens (
-    version,
-    getBinDir, getLibDir, getDynLibDir, getDataDir, getLibexecDir,
-    getDataFileName, getSysconfDir
-  ) where
-
-import qualified Control.Exception as Exception
-import Data.Version (Version(..))
-import System.Environment (getEnv)
-import Prelude
-
-#if defined(VERSION_base)
-
-#if MIN_VERSION_base(4,0,0)
-catchIO :: IO a -> (Exception.IOException -> IO a) -> IO a
-#else
-catchIO :: IO a -> (Exception.Exception -> IO a) -> IO a
-#endif
-
-#else
-catchIO :: IO a -> (Exception.IOException -> IO a) -> IO a
-#endif
-catchIO = Exception.catch
-
-version :: Version
-version = Version [0,1,0,0] []
-bindir, libdir, dynlibdir, datadir, libexecdir, sysconfdir :: FilePath
-
-bindir     = "/home/sv/src/8queens/.stack-work/install/x86_64-linux/lts-13.22/8.6.5/bin"
-libdir     = "/home/sv/src/8queens/.stack-work/install/x86_64-linux/lts-13.22/8.6.5/lib/x86_64-linux-ghc-8.6.5/8queens-0.1.0.0-1f9e2RemoZD8IyN03WXtS0-8queens"
-dynlibdir  = "/home/sv/src/8queens/.stack-work/install/x86_64-linux/lts-13.22/8.6.5/lib/x86_64-linux-ghc-8.6.5"
-datadir    = "/home/sv/src/8queens/.stack-work/install/x86_64-linux/lts-13.22/8.6.5/share/x86_64-linux-ghc-8.6.5/8queens-0.1.0.0"
-libexecdir = "/home/sv/src/8queens/.stack-work/install/x86_64-linux/lts-13.22/8.6.5/libexec/x86_64-linux-ghc-8.6.5/8queens-0.1.0.0"
-sysconfdir = "/home/sv/src/8queens/.stack-work/install/x86_64-linux/lts-13.22/8.6.5/etc"
-
-getBinDir, getLibDir, getDynLibDir, getDataDir, getLibexecDir, getSysconfDir :: IO FilePath
-getBinDir = catchIO (getEnv "8queens_bindir") (\_ -> return bindir)
-getLibDir = catchIO (getEnv "8queens_libdir") (\_ -> return libdir)
-getDynLibDir = catchIO (getEnv "8queens_dynlibdir") (\_ -> return dynlibdir)
-getDataDir = catchIO (getEnv "8queens_datadir") (\_ -> return datadir)
-getLibexecDir = catchIO (getEnv "8queens_libexecdir") (\_ -> return libexecdir)
-getSysconfDir = catchIO (getEnv "8queens_sysconfdir") (\_ -> return sysconfdir)
-
-getDataFileName :: FilePath -> IO FilePath
-getDataFileName name = do
-  dir <- getDataDir
-  return (dir ++ "/" ++ name)
diff --git a/.stack-work/dist/x86_64-linux/Cabal-2.4.0.1/build/8queens/autogen/cabal_macros.h b/.stack-work/dist/x86_64-linux/Cabal-2.4.0.1/build/8queens/autogen/cabal_macros.h
deleted file mode 100644
index 80cc9e2..0000000
--- a/.stack-work/dist/x86_64-linux/Cabal-2.4.0.1/build/8queens/autogen/cabal_macros.h
+++ /dev/null
@@ -1,195 +0,0 @@
-/* DO NOT EDIT: This file is automatically generated by Cabal */
-
-/* package 8queens-0.1.0.0 */
-#ifndef VERSION_8queens
-#define VERSION_8queens "0.1.0.0"
-#endif /* VERSION_8queens */
-#ifndef MIN_VERSION_8queens
-#define MIN_VERSION_8queens(major1,major2,minor) (\
-  (major1) <  0 || \
-  (major1) == 0 && (major2) <  1 || \
-  (major1) == 0 && (major2) == 1 && (minor) <= 0)
-#endif /* MIN_VERSION_8queens */
-
-/* package base-4.12.0.0 */
-#ifndef VERSION_base
-#define VERSION_base "4.12.0.0"
-#endif /* VERSION_base */
-#ifndef MIN_VERSION_base
-#define MIN_VERSION_base(major1,major2,minor) (\
-  (major1) <  4 || \
-  (major1) == 4 && (major2) <  12 || \
-  (major1) == 4 && (major2) == 12 && (minor) <= 0)
-#endif /* MIN_VERSION_base */
-
-/* package lens-4.17.1 */
-#ifndef VERSION_lens
-#define VERSION_lens "4.17.1"
-#endif /* VERSION_lens */
-#ifndef MIN_VERSION_lens
-#define MIN_VERSION_lens(major1,major2,minor) (\
-  (major1) <  4 || \
-  (major1) == 4 && (major2) <  17 || \
-  (major1) == 4 && (major2) == 17 && (minor) <= 1)
-#endif /* MIN_VERSION_lens */
-
-/* package linear-1.20.9 */
-#ifndef VERSION_linear
-#define VERSION_linear "1.20.9"
-#endif /* VERSION_linear */
-#ifndef MIN_VERSION_linear
-#define MIN_VERSION_linear(major1,major2,minor) (\
-  (major1) <  1 || \
-  (major1) == 1 && (major2) <  20 || \
-  (major1) == 1 && (major2) == 20 && (minor) <= 9)
-#endif /* MIN_VERSION_linear */
-
-/* package matrix-0.3.6.1 */
-#ifndef VERSION_matrix
-#define VERSION_matrix "0.3.6.1"
-#endif /* VERSION_matrix */
-#ifndef MIN_VERSION_matrix
-#define MIN_VERSION_matrix(major1,major2,minor) (\
-  (major1) <  0 || \
-  (major1) == 0 && (major2) <  3 || \
-  (major1) == 0 && (major2) == 3 && (minor) <= 6)
-#endif /* MIN_VERSION_matrix */
-
-/* package random-1.1 */
-#ifndef VERSION_random
-#define VERSION_random "1.1"
-#endif /* VERSION_random */
-#ifndef MIN_VERSION_random
-#define MIN_VERSION_random(major1,major2,minor) (\
-  (major1) <  1 || \
-  (major1) == 1 && (major2) <  1 || \
-  (major1) == 1 && (major2) == 1 && (minor) <= 0)
-#endif /* MIN_VERSION_random */
-
-/* package vector-0.12.0.3 */
-#ifndef VERSION_vector
-#define VERSION_vector "0.12.0.3"
-#endif /* VERSION_vector */
-#ifndef MIN_VERSION_vector
-#define MIN_VERSION_vector(major1,major2,minor) (\
-  (major1) <  0 || \
-  (major1) == 0 && (major2) <  12 || \
-  (major1) == 0 && (major2) == 12 && (minor) <= 0)
-#endif /* MIN_VERSION_vector */
-
-/* tool gcc-6.3.0 */
-#ifndef TOOL_VERSION_gcc
-#define TOOL_VERSION_gcc "6.3.0"
-#endif /* TOOL_VERSION_gcc */
-#ifndef MIN_TOOL_VERSION_gcc
-#define MIN_TOOL_VERSION_gcc(major1,major2,minor) (\
-  (major1) <  6 || \
-  (major1) == 6 && (major2) <  3 || \
-  (major1) == 6 && (major2) == 3 && (minor) <= 0)
-#endif /* MIN_TOOL_VERSION_gcc */
-
-/* tool ghc-8.6.5 */
-#ifndef TOOL_VERSION_ghc
-#define TOOL_VERSION_ghc "8.6.5"
-#endif /* TOOL_VERSION_ghc */
-#ifndef MIN_TOOL_VERSION_ghc
-#define MIN_TOOL_VERSION_ghc(major1,major2,minor) (\
-  (major1) <  8 || \
-  (major1) == 8 && (major2) <  6 || \
-  (major1) == 8 && (major2) == 6 && (minor) <= 5)
-#endif /* MIN_TOOL_VERSION_ghc */
-
-/* tool ghc-pkg-8.6.5 */
-#ifndef TOOL_VERSION_ghc_pkg
-#define TOOL_VERSION_ghc_pkg "8.6.5"
-#endif /* TOOL_VERSION_ghc_pkg */
-#ifndef MIN_TOOL_VERSION_ghc_pkg
-#define MIN_TOOL_VERSION_ghc_pkg(major1,major2,minor) (\
-  (major1) <  8 || \
-  (major1) == 8 && (major2) <  6 || \
-  (major1) == 8 && (major2) == 6 && (minor) <= 5)
-#endif /* MIN_TOOL_VERSION_ghc_pkg */
-
-/* tool haddock-2.22.0 */
-#ifndef TOOL_VERSION_haddock
-#define TOOL_VERSION_haddock "2.22.0"
-#endif /* TOOL_VERSION_haddock */
-#ifndef MIN_TOOL_VERSION_haddock
-#define MIN_TOOL_VERSION_haddock(major1,major2,minor) (\
-  (major1) <  2 || \
-  (major1) == 2 && (major2) <  22 || \
-  (major1) == 2 && (major2) == 22 && (minor) <= 0)
-#endif /* MIN_TOOL_VERSION_haddock */
-
-/* tool happy-1.19.9 */
-#ifndef TOOL_VERSION_happy
-#define TOOL_VERSION_happy "1.19.9"
-#endif /* TOOL_VERSION_happy */
-#ifndef MIN_TOOL_VERSION_happy
-#define MIN_TOOL_VERSION_happy(major1,major2,minor) (\
-  (major1) <  1 || \
-  (major1) == 1 && (major2) <  19 || \
-  (major1) == 1 && (major2) == 19 && (minor) <= 9)
-#endif /* MIN_TOOL_VERSION_happy */
-
-/* tool hpc-0.67 */
-#ifndef TOOL_VERSION_hpc
-#define TOOL_VERSION_hpc "0.67"
-#endif /* TOOL_VERSION_hpc */
-#ifndef MIN_TOOL_VERSION_hpc
-#define MIN_TOOL_VERSION_hpc(major1,major2,minor) (\
-  (major1) <  0 || \
-  (major1) == 0 && (major2) <  67 || \
-  (major1) == 0 && (major2) == 67 && (minor) <= 0)
-#endif /* MIN_TOOL_VERSION_hpc */
-
-/* tool hsc2hs-0.68.5 */
-#ifndef TOOL_VERSION_hsc2hs
-#define TOOL_VERSION_hsc2hs "0.68.5"
-#endif /* TOOL_VERSION_hsc2hs */
-#ifndef MIN_TOOL_VERSION_hsc2hs
-#define MIN_TOOL_VERSION_hsc2hs(major1,major2,minor) (\
-  (major1) <  0 || \
-  (major1) == 0 && (major2) <  68 || \
-  (major1) == 0 && (major2) == 68 && (minor) <= 5)
-#endif /* MIN_TOOL_VERSION_hsc2hs */
-
-/* tool pkg-config-0.29 */
-#ifndef TOOL_VERSION_pkg_config
-#define TOOL_VERSION_pkg_config "0.29"
-#endif /* TOOL_VERSION_pkg_config */
-#ifndef MIN_TOOL_VERSION_pkg_config
-#define MIN_TOOL_VERSION_pkg_config(major1,major2,minor) (\
-  (major1) <  0 || \
-  (major1) == 0 && (major2) <  29 || \
-  (major1) == 0 && (major2) == 29 && (minor) <= 0)
-#endif /* MIN_TOOL_VERSION_pkg_config */
-
-/* tool runghc-8.6.5 */
-#ifndef TOOL_VERSION_runghc
-#define TOOL_VERSION_runghc "8.6.5"
-#endif /* TOOL_VERSION_runghc */
-#ifndef MIN_TOOL_VERSION_runghc
-#define MIN_TOOL_VERSION_runghc(major1,major2,minor) (\
-  (major1) <  8 || \
-  (major1) == 8 && (major2) <  6 || \
-  (major1) == 8 && (major2) == 6 && (minor) <= 5)
-#endif /* MIN_TOOL_VERSION_runghc */
-
-/* tool strip-2.28 */
-#ifndef TOOL_VERSION_strip
-#define TOOL_VERSION_strip "2.28"
-#endif /* TOOL_VERSION_strip */
-#ifndef MIN_TOOL_VERSION_strip
-#define MIN_TOOL_VERSION_strip(major1,major2,minor) (\
-  (major1) <  2 || \
-  (major1) == 2 && (major2) <  28 || \
-  (major1) == 2 && (major2) == 28 && (minor) <= 0)
-#endif /* MIN_TOOL_VERSION_strip */
-
-#ifndef CURRENT_COMPONENT_ID
-#define CURRENT_COMPONENT_ID "8queens-0.1.0.0-1f9e2RemoZD8IyN03WXtS0-8queens"
-#endif /* CURRENT_COMPONENT_ID */
-#ifndef CURRENT_PACKAGE_VERSION
-#define CURRENT_PACKAGE_VERSION "0.1.0.0"
-#endif /* CURRENT_PACKAGE_VERSION */
diff --git a/.stack-work/dist/x86_64-linux/Cabal-2.4.0.1/package.conf.inplace/package.cache b/.stack-work/dist/x86_64-linux/Cabal-2.4.0.1/package.conf.inplace/package.cache
deleted file mode 100644
index b3cae5c..0000000
--- a/.stack-work/dist/x86_64-linux/Cabal-2.4.0.1/package.conf.inplace/package.cache
+++ /dev/null
diff --git a/.stack-work/dist/x86_64-linux/Cabal-2.4.0.1/package.conf.inplace/package.cache.lock b/.stack-work/dist/x86_64-linux/Cabal-2.4.0.1/package.conf.inplace/package.cache.lock
deleted file mode 100644
index e69de29..0000000
--- a/.stack-work/dist/x86_64-linux/Cabal-2.4.0.1/package.conf.inplace/package.cache.lock
+++ /dev/null
diff --git a/.stack-work/dist/x86_64-linux/Cabal-2.4.0.1/setup-config b/.stack-work/dist/x86_64-linux/Cabal-2.4.0.1/setup-config
deleted file mode 100644
index 81c2525..0000000
--- a/.stack-work/dist/x86_64-linux/Cabal-2.4.0.1/setup-config
+++ /dev/null
diff --git a/.stack-work/dist/x86_64-linux/Cabal-2.4.0.1/stack-build-caches/exe-8queens b/.stack-work/dist/x86_64-linux/Cabal-2.4.0.1/stack-build-caches/exe-8queens
deleted file mode 100644
index a41b89b..0000000
--- a/.stack-work/dist/x86_64-linux/Cabal-2.4.0.1/stack-build-caches/exe-8queens
+++ /dev/null
diff --git a/.stack-work/dist/x86_64-linux/Cabal-2.4.0.1/stack-cabal-mod b/.stack-work/dist/x86_64-linux/Cabal-2.4.0.1/stack-cabal-mod
deleted file mode 100644
index 13bd001..0000000
--- a/.stack-work/dist/x86_64-linux/Cabal-2.4.0.1/stack-cabal-mod
+++ /dev/null
diff --git a/.stack-work/dist/x86_64-linux/Cabal-2.4.0.1/stack-config-cache b/.stack-work/dist/x86_64-linux/Cabal-2.4.0.1/stack-config-cache
deleted file mode 100644
index 4a70cec..0000000
--- a/.stack-work/dist/x86_64-linux/Cabal-2.4.0.1/stack-config-cache
+++ /dev/null
diff --git a/.stack-work/ghci/3a535720/cabal_macros.h b/.stack-work/ghci/3a535720/cabal_macros.h
deleted file mode 100644
index 38daada..0000000
--- a/.stack-work/ghci/3a535720/cabal_macros.h
+++ /dev/null
@@ -1,198 +0,0 @@
-/* DO NOT EDIT: This file is automatically generated by Cabal */
-
-/* package 8queens-0.1.0.0 */
-#ifndef VERSION_8queens
-#define VERSION_8queens "0.1.0.0"
-#endif /* VERSION_8queens */
-#ifndef MIN_VERSION_8queens
-#define MIN_VERSION_8queens(major1,major2,minor) (\
-  (major1) <  0 || \
-  (major1) == 0 && (major2) <  1 || \
-  (major1) == 0 && (major2) == 1 && (minor) <= 0)
-#endif /* MIN_VERSION_8queens */
-
-/* package base-4.12.0.0 */
-#ifndef VERSION_base
-#define VERSION_base "4.12.0.0"
-#endif /* VERSION_base */
-#ifndef MIN_VERSION_base
-#define MIN_VERSION_base(major1,major2,minor) (\
-  (major1) <  4 || \
-  (major1) == 4 && (major2) <  12 || \
-  (major1) == 4 && (major2) == 12 && (minor) <= 0)
-#endif /* MIN_VERSION_base */
-
-/* package lens-4.17.1 */
-#ifndef VERSION_lens
-#define VERSION_lens "4.17.1"
-#endif /* VERSION_lens */
-#ifndef MIN_VERSION_lens
-#define MIN_VERSION_lens(major1,major2,minor) (\
-  (major1) <  4 || \
-  (major1) == 4 && (major2) <  17 || \
-  (major1) == 4 && (major2) == 17 && (minor) <= 1)
-#endif /* MIN_VERSION_lens */
-
-/* package linear-1.20.9 */
-#ifndef VERSION_linear
-#define VERSION_linear "1.20.9"
-#endif /* VERSION_linear */
-#ifndef MIN_VERSION_linear
-#define MIN_VERSION_linear(major1,major2,minor) (\
-  (major1) <  1 || \
-  (major1) == 1 && (major2) <  20 || \
-  (major1) == 1 && (major2) == 20 && (minor) <= 9)
-#endif /* MIN_VERSION_linear */
-
-/* package matrix-0.3.6.1 */
-#ifndef VERSION_matrix
-#define VERSION_matrix "0.3.6.1"
-#endif /* VERSION_matrix */
-#ifndef MIN_VERSION_matrix
-#define MIN_VERSION_matrix(major1,major2,minor) (\
-  (major1) <  0 || \
-  (major1) == 0 && (major2) <  3 || \
-  (major1) == 0 && (major2) == 3 && (minor) <= 6)
-#endif /* MIN_VERSION_matrix */
-
-/* package random-1.1 */
-#ifndef VERSION_random
-#define VERSION_random "1.1"
-#endif /* VERSION_random */
-#ifndef MIN_VERSION_random
-#define MIN_VERSION_random(major1,major2,minor) (\
-  (major1) <  1 || \
-  (major1) == 1 && (major2) <  1 || \
-  (major1) == 1 && (major2) == 1 && (minor) <= 0)
-#endif /* MIN_VERSION_random */
-
-/* package vector-0.12.0.3 */
-#ifndef VERSION_vector
-#define VERSION_vector "0.12.0.3"
-#endif /* VERSION_vector */
-#ifndef MIN_VERSION_vector
-#define MIN_VERSION_vector(major1,major2,minor) (\
-  (major1) <  0 || \
-  (major1) == 0 && (major2) <  12 || \
-  (major1) == 0 && (major2) == 12 && (minor) <= 0)
-#endif /* MIN_VERSION_vector */
-
-/* tool gcc-6.3.0 */
-#ifndef TOOL_VERSION_gcc
-#define TOOL_VERSION_gcc "6.3.0"
-#endif /* TOOL_VERSION_gcc */
-#ifndef MIN_TOOL_VERSION_gcc
-#define MIN_TOOL_VERSION_gcc(major1,major2,minor) (\
-  (major1) <  6 || \
-  (major1) == 6 && (major2) <  3 || \
-  (major1) == 6 && (major2) == 3 && (minor) <= 0)
-#endif /* MIN_TOOL_VERSION_gcc */
-
-/* tool ghc-8.6.5 */
-#ifndef TOOL_VERSION_ghc
-#define TOOL_VERSION_ghc "8.6.5"
-#endif /* TOOL_VERSION_ghc */
-#ifndef MIN_TOOL_VERSION_ghc
-#define MIN_TOOL_VERSION_ghc(major1,major2,minor) (\
-  (major1) <  8 || \
-  (major1) == 8 && (major2) <  6 || \
-  (major1) == 8 && (major2) == 6 && (minor) <= 5)
-#endif /* MIN_TOOL_VERSION_ghc */
-
-/* tool ghc-pkg-8.6.5 */
-#ifndef TOOL_VERSION_ghc_pkg
-#define TOOL_VERSION_ghc_pkg "8.6.5"
-#endif /* TOOL_VERSION_ghc_pkg */
-#ifndef MIN_TOOL_VERSION_ghc_pkg
-#define MIN_TOOL_VERSION_ghc_pkg(major1,major2,minor) (\
-  (major1) <  8 || \
-  (major1) == 8 && (major2) <  6 || \
-  (major1) == 8 && (major2) == 6 && (minor) <= 5)
-#endif /* MIN_TOOL_VERSION_ghc_pkg */
-
-/* tool haddock-2.22.0 */
-#ifndef TOOL_VERSION_haddock
-#define TOOL_VERSION_haddock "2.22.0"
-#endif /* TOOL_VERSION_haddock */
-#ifndef MIN_TOOL_VERSION_haddock
-#define MIN_TOOL_VERSION_haddock(major1,major2,minor) (\
-  (major1) <  2 || \
-  (major1) == 2 && (major2) <  22 || \
-  (major1) == 2 && (major2) == 22 && (minor) <= 0)
-#endif /* MIN_TOOL_VERSION_haddock */
-
-/* tool happy-1.19.9 */
-#ifndef TOOL_VERSION_happy
-#define TOOL_VERSION_happy "1.19.9"
-#endif /* TOOL_VERSION_happy */
-#ifndef MIN_TOOL_VERSION_happy
-#define MIN_TOOL_VERSION_happy(major1,major2,minor) (\
-  (major1) <  1 || \
-  (major1) == 1 && (major2) <  19 || \
-  (major1) == 1 && (major2) == 19 && (minor) <= 9)
-#endif /* MIN_TOOL_VERSION_happy */
-
-/* tool hpc-0.67 */
-#ifndef TOOL_VERSION_hpc
-#define TOOL_VERSION_hpc "0.67"
-#endif /* TOOL_VERSION_hpc */
-#ifndef MIN_TOOL_VERSION_hpc
-#define MIN_TOOL_VERSION_hpc(major1,major2,minor) (\
-  (major1) <  0 || \
-  (major1) == 0 && (major2) <  67 || \
-  (major1) == 0 && (major2) == 67 && (minor) <= 0)
-#endif /* MIN_TOOL_VERSION_hpc */
-
-/* tool hsc2hs-0.68.5 */
-#ifndef TOOL_VERSION_hsc2hs
-#define TOOL_VERSION_hsc2hs "0.68.5"
-#endif /* TOOL_VERSION_hsc2hs */
-#ifndef MIN_TOOL_VERSION_hsc2hs
-#define MIN_TOOL_VERSION_hsc2hs(major1,major2,minor) (\
-  (major1) <  0 || \
-  (major1) == 0 && (major2) <  68 || \
-  (major1) == 0 && (major2) == 68 && (minor) <= 5)
-#endif /* MIN_TOOL_VERSION_hsc2hs */
-
-/* tool pkg-config-0.29 */
-#ifndef TOOL_VERSION_pkg_config
-#define TOOL_VERSION_pkg_config "0.29"
-#endif /* TOOL_VERSION_pkg_config */
-#ifndef MIN_TOOL_VERSION_pkg_config
-#define MIN_TOOL_VERSION_pkg_config(major1,major2,minor) (\
-  (major1) <  0 || \
-  (major1) == 0 && (major2) <  29 || \
-  (major1) == 0 && (major2) == 29 && (minor) <= 0)
-#endif /* MIN_TOOL_VERSION_pkg_config */
-
-/* tool runghc-8.6.5 */
-#ifndef TOOL_VERSION_runghc
-#define TOOL_VERSION_runghc "8.6.5"
-#endif /* TOOL_VERSION_runghc */
-#ifndef MIN_TOOL_VERSION_runghc
-#define MIN_TOOL_VERSION_runghc(major1,major2,minor) (\
-  (major1) <  8 || \
-  (major1) == 8 && (major2) <  6 || \
-  (major1) == 8 && (major2) == 6 && (minor) <= 5)
-#endif /* MIN_TOOL_VERSION_runghc */
-
-/* tool strip-2.28 */
-#ifndef TOOL_VERSION_strip
-#define TOOL_VERSION_strip "2.28"
-#endif /* TOOL_VERSION_strip */
-#ifndef MIN_TOOL_VERSION_strip
-#define MIN_TOOL_VERSION_strip(major1,major2,minor) (\