path: root/.stack-work/dist/x86_64-linux/Cabal-2.4.0.1/build/8queens/8queens-tmp/src/Main.dump-hi

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