HC = /home/tora/msr-ghc/ghc-Stack/ghc/stage2-inplace/ghc
HC_OPTS = -O -H64m -O -Rghc-timing -H32m -hisuf hi -fglasgow-exts -fexplicit-call-stack-all -ddump-if-trace
RUNTEST_OPTS = -ghc-timing
==nofib== cryptarithm2: time to compile Main follows...
/home/tora/msr-ghc/ghc-Stack/ghc/stage2-inplace/ghc -O -H64m -O -Rghc-timing -H32m -hisuf hi -fglasgow-exts -fexplicit-call-stack-all -ddump-if-trace -c Main.hs -o Main.o
FYI: cannot read old interface file:
    Main.hi: openBinaryFile: does not exist (No such file or directory)
Considering whether to load base:Prelude
Reading interface for base:Prelude;
    reason: Prelude is directly imported
readIFace /home/tora/msr-ghc/ghc-Stack/libraries/base/dist/build/Prelude.hi
updating EPS_
Considering whether to load haskell98:Monad
Reading interface for haskell98:Monad;
    reason: Monad is directly imported
readIFace /home/tora/msr-ghc/ghc-Stack/libraries/haskell98/dist/build/Monad.hi
updating EPS_
Considering whether to load main:MonadState
Reading interface for main:MonadState;
    reason: MonadState is directly imported
readIFace ./MonadState.hi
updating EPS_
Considering whether to load haskell98:List
Reading interface for haskell98:List;
    reason: List is directly imported
readIFace /home/tora/msr-ghc/ghc-Stack/libraries/haskell98/dist/build/List.hi
updating EPS_
Considering whether to load haskell98:Maybe
Reading interface for haskell98:Maybe;
    reason: Maybe is directly imported
readIFace /home/tora/msr-ghc/ghc-Stack/libraries/haskell98/dist/build/Maybe.hi
updating EPS_
updating EPS_
Loading orphan modules: base:Control.Exception.Base base:Data.Tuple
                        base:GHC.Base base:GHC.Float base:GHC.Num
Considering whether to load base:Control.Exception.Base {- SYSTEM -}
Reading interface for base:Control.Exception.Base;
    reason: base:Control.Exception.Base is a orphan-instance module
readIFace /home/tora/msr-ghc/ghc-Stack/libraries/base/dist/build/Control/Exception/Base.hi
updating EPS_
Considering whether to load base:Data.Tuple {- SYSTEM -}
Reading interface for base:Data.Tuple;
    reason: base:Data.Tuple is a orphan-instance module
readIFace /home/tora/msr-ghc/ghc-Stack/libraries/base/dist/build/Data/Tuple.hi
updating EPS_
Considering whether to load base:GHC.Base {- SYSTEM -}
Reading interface for base:GHC.Base;
    reason: base:GHC.Base is a orphan-instance module
readIFace /home/tora/msr-ghc/ghc-Stack/libraries/base/dist/build/GHC/Base.hi
updating EPS_
Considering whether to load base:GHC.Float {- SYSTEM -}
Reading interface for base:GHC.Float;
    reason: base:GHC.Float is a orphan-instance module
readIFace /home/tora/msr-ghc/ghc-Stack/libraries/base/dist/build/GHC/Float.hi
updating EPS_
Considering whether to load base:GHC.Num {- SYSTEM -}
Reading interface for base:GHC.Num;
    reason: base:GHC.Num is a orphan-instance module
readIFace /home/tora/msr-ghc/ghc-Stack/libraries/base/dist/build/GHC/Num.hi
updating EPS_
loadHiBootInterface main:Main
Considering whether to load base:Data.List {- SYSTEM -}
Reading interface for base:Data.List;
    reason: Checking fixity for Data.List.\\
readIFace /home/tora/msr-ghc/ghc-Stack/libraries/base/dist/build/Data/List.hi
updating EPS_
Considering whether to load ghc-prim:GHC.Types {- SYSTEM -}
Reading interface for ghc-prim:GHC.Types;
    reason: Checking fixity for :
readIFace /home/tora/msr-ghc/ghc-Stack/libraries/ghc-prim/dist/build/GHC/Types.hi
updating EPS_
Considering whether to load ghc-prim:GHC.Types {- SYSTEM -}
Considering whether to load ghc-prim:GHC.Types {- SYSTEM -}
Considering whether to load ghc-prim:GHC.Types {- SYSTEM -}
Considering whether to load base:GHC.Num {- SYSTEM -}
Considering whether to load base:GHC.Real {- SYSTEM -}
Reading interface for base:GHC.Real;
    reason: Checking fixity for GHC.Real.mod
readIFace /home/tora/msr-ghc/ghc-Stack/libraries/base/dist/build/GHC/Real.hi
updating EPS_
Considering whether to load base:GHC.Classes {- SYSTEM -}
Reading interface for base:GHC.Classes;
    reason: Checking fixity for GHC.Classes.==
readIFace /home/tora/msr-ghc/ghc-Stack/libraries/base/dist/build/GHC/Classes.hi
updating EPS_
Considering whether to load base:GHC.Real {- SYSTEM -}
Considering whether to load ghc-prim:GHC.Types {- SYSTEM -}
Considering whether to load base:GHC.Num {- SYSTEM -}
Considering whether to load base:GHC.Num {- SYSTEM -}
Considering whether to load base:GHC.Base {- SYSTEM -}
Considering whether to load base:GHC.Classes {- SYSTEM -}
Considering whether to load base:GHC.Classes {- SYSTEM -}
Considering whether to load base:GHC.Base {- SYSTEM -}
Considering whether to load base:GHC.Base {- SYSTEM -}
Starting fork { Declaration for StateT
Loading decl for MonadState.StateT
updating EPS_
mkNewTyConRhs Just MonadState.NTCo:StateT
tcIfaceDecl4 MonadState.StateT
} ending fork Declaration for StateT
Considering whether to load ghc-prim:GHC.Types {- SYSTEM -}
Considering whether to load ghc-prim:GHC.Types {- SYSTEM -}
Considering whether to load ghc-prim:GHC.Types {- SYSTEM -}
Considering whether to load ghc-prim:GHC.Types {- SYSTEM -}
Considering whether to load ghc-prim:GHC.Types {- SYSTEM -}
Considering whether to load ghc-prim:GHC.Types {- SYSTEM -}
Considering whether to load ghc-prim:GHC.Types {- SYSTEM -}
Considering whether to load ghc-prim:GHC.Types {- SYSTEM -}
Considering whether to load ghc-prim:GHC.Types {- SYSTEM -}
Considering whether to load ghc-prim:GHC.Tuple {- SYSTEM -}
Reading interface for ghc-prim:GHC.Tuple;
    reason: Need home interface for wired-in thing (,)
readIFace /home/tora/msr-ghc/ghc-Stack/libraries/ghc-prim/dist/build/GHC/Tuple.hi
updating EPS_
Considering whether to load ghc-prim:GHC.Types {- SYSTEM -}
tcImportDecl GHC.Show.Show
Need decl for GHC.Show.Show
Considering whether to load base:GHC.Show {- SYSTEM -}
Reading interface for base:GHC.Show;
    reason: Need decl for GHC.Show.Show
readIFace /home/tora/msr-ghc/ghc-Stack/libraries/base/dist/build/GHC/Show.hi
updating EPS_
Starting fork { Declaration for Show
Loading decl for GHC.Show.Show
updating EPS_
buildClass
buildClass GHC.Show.T:Show
} ending fork Declaration for Show
Starting fork { Dict fun GHC.Show.$f20
Starting fork { Declaration for $f20
Loading decl for GHC.Show.$f20
updating EPS_
Considering whether to load ghc-prim:GHC.Types {- SYSTEM -}
} ending fork Declaration for $f20
} ending fork Dict fun GHC.Show.$f20
Starting fork { Dict fun GHC.Show.$f16
Starting fork { Declaration for $f16
Loading decl for GHC.Show.$f16
updating EPS_
Considering whether to load ghc-prim:GHC.Types {- SYSTEM -}
} ending fork Declaration for $f16
} ending fork Dict fun GHC.Show.$f16
Starting fork { Dict fun GHC.Show.$f14
Starting fork { Declaration for $f14
Loading decl for GHC.Show.$f14
updating EPS_
Considering whether to load ghc-prim:GHC.Tuple {- SYSTEM -}
} ending fork Declaration for $f14
} ending fork Dict fun GHC.Show.$f14
Starting fork { Dict fun GHC.Show.$f17
Starting fork { Declaration for $f17
Loading decl for GHC.Show.$f17
updating EPS_
Considering whether to load ghc-prim:GHC.Types {- SYSTEM -}
} ending fork Declaration for $f17
} ending fork Dict fun GHC.Show.$f17
Considering whether to load base:GHC.Classes {- SYSTEM -}
Considering whether to load ghc-prim:GHC.Types {- SYSTEM -}
Considering whether to load ghc-prim:GHC.Types {- SYSTEM -}
Starting fork { Declaration for String
Loading decl for GHC.Base.String
updating EPS_
Starting fork { Type syonym GHC.Base.String
Considering whether to load ghc-prim:GHC.Types {- SYSTEM -}
Considering whether to load ghc-prim:GHC.Types {- SYSTEM -}
} ending fork Type syonym GHC.Base.String
} ending fork Declaration for String
Considering whether to load ghc-prim:GHC.Types {- SYSTEM -}
Considering whether to load ghc-prim:GHC.Types {- SYSTEM -}
Considering whether to load ghc-prim:GHC.Types {- SYSTEM -}
Considering whether to load ghc-prim:GHC.Types {- SYSTEM -}
Considering whether to load ghc-prim:GHC.Types {- SYSTEM -}
Considering whether to load ghc-prim:GHC.Types {- SYSTEM -}
Considering whether to load ghc-prim:GHC.Types {- SYSTEM -}
Considering whether to load ghc-prim:GHC.Types {- SYSTEM -}
Considering whether to load ghc-prim:GHC.Unit {- SYSTEM -}
Reading interface for ghc-prim:GHC.Unit;
    reason: Need home interface for wired-in thing ()
readIFace /home/tora/msr-ghc/ghc-Stack/libraries/ghc-prim/dist/build/GHC/Unit.hi
updating EPS_
Considering whether to load ghc-prim:GHC.Types {- SYSTEM -}
Considering whether to load ghc-prim:GHC.Types {- SYSTEM -}
Considering whether to load ghc-prim:GHC.Types {- SYSTEM -}
Considering whether to load ghc-prim:GHC.Types {- SYSTEM -}
Considering whether to load ghc-prim:GHC.Types {- SYSTEM -}
Considering whether to load ghc-prim:GHC.Types {- SYSTEM -}
Considering whether to load ghc-prim:GHC.Unit {- SYSTEM -}
Considering whether to load ghc-prim:GHC.Types {- SYSTEM -}
Considering whether to load ghc-prim:GHC.Types {- SYSTEM -}
Considering whether to load ghc-prim:GHC.Types {- SYSTEM -}
Considering whether to load ghc-prim:GHC.Types {- SYSTEM -}
Considering whether to load ghc-prim:GHC.Types {- SYSTEM -}
Considering whether to load ghc-prim:GHC.Types {- SYSTEM -}
Considering whether to load ghc-prim:GHC.Types {- SYSTEM -}
Considering whether to load ghc-prim:GHC.Types {- SYSTEM -}
Starting fork { Declaration for MonadState
Loading decl for MonadState.MonadState
updating EPS_
buildClass
buildClass MonadState.T:MonadState
} ending fork Declaration for MonadState
Starting fork { Class op MonadState.get m s
} ending fork Class op MonadState.get m s
Starting fork { Declaration for Monad
Loading decl for GHC.Base.Monad
updating EPS_
buildClass
buildClass GHC.Base.T:Monad
} ending fork Declaration for Monad
Starting fork { Class op GHC.Base.>>=
                         forall a b. m a -> (a -> m b) -> m b
} ending fork Class op GHC.Base.>>=
                       forall a b. m a -> (a -> m b) -> m b
tcImportDecl MonadTrans.lift
Need decl for MonadTrans.lift
Considering whether to load main:MonadTrans {- SYSTEM -}
Reading interface for main:MonadTrans;
    reason: Need decl for MonadTrans.lift
readIFace ./MonadTrans.hi
updating EPS_
Starting fork { Declaration for MonadTrans
Loading decl for MonadTrans.MonadTrans
updating EPS_
buildClass
mkNewTyConRhs Just MonadTrans.NTCo:T:MonadTrans
buildClass MonadTrans.T:MonadTrans
} ending fork Declaration for MonadTrans
Starting fork { Class op MonadTrans.lift
                         forall (m::* -> *) a. GHC.Base.Monad m => m a -> t m a
} ending fork Class op MonadTrans.lift
                       forall (m::* -> *) a. GHC.Base.Monad m => m a -> t m a
Considering whether to load ghc-prim:GHC.Types {- SYSTEM -}
Considering whether to load ghc-prim:GHC.Tuple {- SYSTEM -}
Starting fork { Declaration for \\
Loading decl for Data.List.\\
updating EPS_
Considering whether to load ghc-prim:GHC.Types {- SYSTEM -}
Considering whether to load ghc-prim:GHC.Types {- SYSTEM -}
Considering whether to load ghc-prim:GHC.Types {- SYSTEM -}
} ending fork Declaration for \\
Considering whether to load ghc-prim:GHC.Types {- SYSTEM -}
Considering whether to load ghc-prim:GHC.Tuple {- SYSTEM -}
Starting fork { Class op MonadState.put s -> m ()
Considering whether to load ghc-prim:GHC.Unit {- SYSTEM -}
} ending fork Class op MonadState.put s -> m ()
Considering whether to load ghc-prim:GHC.Tuple {- SYSTEM -}
Starting fork { Class op GHC.Base.>> forall a b. m a -> m b -> m b
} ending fork Class op GHC.Base.>> forall a b. m a -> m b -> m b
Starting fork { Class op GHC.Base.return forall a. a -> m a
} ending fork Class op GHC.Base.return forall a. a -> m a
Starting fork { Declaration for Eq
Loading decl for GHC.Classes.Eq
updating EPS_
buildClass
buildClass GHC.Classes.T:Eq
} ending fork Declaration for Eq
Starting fork { Dict fun GHC.Base.$f2
Starting fork { Declaration for $f2
Loading decl for GHC.Base.$f2
updating EPS_
Considering whether to load ghc-prim:GHC.Types {- SYSTEM -}
} ending fork Declaration for $f2
} ending fork Dict fun GHC.Base.$f2
Starting fork { Dict fun MonadState.$f1
Starting fork { Declaration for $f1
Loading decl for MonadState.$f1
updating EPS_
} ending fork Declaration for $f1
} ending fork Dict fun MonadState.$f1
Starting fork { Dict fun GHC.Base.$f9
Starting fork { Declaration for $f9
Loading decl for GHC.Base.$f9
updating EPS_
Considering whether to load ghc-prim:GHC.Types {- SYSTEM -}
} ending fork Declaration for $f9
} ending fork Dict fun GHC.Base.$f9
Starting fork { Dict fun MonadState.$f4
Starting fork { Declaration for $f4
Loading decl for MonadState.$f4
updating EPS_
} ending fork Declaration for $f4
} ending fork Dict fun MonadState.$f4
Starting fork { Dict fun MonadState.$f6
Starting fork { Declaration for $f6
Loading decl for MonadState.$f6
updating EPS_
} ending fork Declaration for $f6
} ending fork Dict fun MonadState.$f6
Starting fork { Declaration for State
Loading decl for MonadState.State
updating EPS_
mkNewTyConRhs Just MonadState.NTCo:State
tcIfaceDecl4 MonadState.State
} ending fork Declaration for State
Starting fork { Dict fun MonadState.$f2
Starting fork { Declaration for $f2
Loading decl for MonadState.$f2
updating EPS_
} ending fork Declaration for $f2
} ending fork Dict fun MonadState.$f2
tcImportDecl GHC.List.lookup
Need decl for GHC.List.lookup
Considering whether to load base:GHC.List {- SYSTEM -}
Reading interface for base:GHC.List;
    reason: Need decl for GHC.List.lookup
readIFace /home/tora/msr-ghc/ghc-Stack/libraries/base/dist/build/GHC/List.hi
updating EPS_
Starting fork { Declaration for lookup
Loading decl for GHC.List.lookup
updating EPS_
Considering whether to load ghc-prim:GHC.Types {- SYSTEM -}
Considering whether to load ghc-prim:GHC.Tuple {- SYSTEM -}
Need decl for Data.Maybe.Maybe
Considering whether to load base:Data.Maybe {- SYSTEM -}
Reading interface for base:Data.Maybe;
    reason: Need decl for Data.Maybe.Maybe
readIFace /home/tora/msr-ghc/ghc-Stack/libraries/base/dist/build/Data/Maybe.hi
updating EPS_
} ending fork Declaration for lookup
Starting fork { Declaration for Maybe
Loading decl for Data.Maybe.Maybe
updating EPS_
tcIfaceDecl4 Data.Maybe.Maybe
} ending fork Declaration for Maybe
Starting fork { Constructor Data.Maybe.Just
} ending fork Constructor Data.Maybe.Just
Starting fork { Constructor Data.Maybe.Nothing
} ending fork Constructor Data.Maybe.Nothing
Starting fork { Dict fun GHC.Base.$f4
Starting fork { Declaration for $f4
Loading decl for GHC.Base.$f4
updating EPS_
Considering whether to load ghc-prim:GHC.Types {- SYSTEM -}
} ending fork Declaration for $f4
} ending fork Dict fun GHC.Base.$f4
Considering whether to load ghc-prim:GHC.Types {- SYSTEM -}
Considering whether to load ghc-prim:GHC.Types {- SYSTEM -}
Considering whether to load ghc-prim:GHC.Types {- SYSTEM -}
Considering whether to load ghc-prim:GHC.Types {- SYSTEM -}
Considering whether to load ghc-prim:GHC.Types {- SYSTEM -}
tcImportDecl Control.Monad.mapM
Need decl for Control.Monad.mapM
Considering whether to load base:Control.Monad {- SYSTEM -}
Reading interface for base:Control.Monad;
    reason: Need decl for Control.Monad.mapM
readIFace /home/tora/msr-ghc/ghc-Stack/libraries/base/dist/build/Control/Monad.hi
updating EPS_
Starting fork { Declaration for mapM
Loading decl for Control.Monad.mapM
updating EPS_
Considering whether to load ghc-prim:GHC.Types {- SYSTEM -}
Considering whether to load ghc-prim:GHC.Types {- SYSTEM -}
} ending fork Declaration for mapM
Starting fork { Declaration for Num
Loading decl for GHC.Num.Num
updating EPS_
buildClass
buildClass GHC.Num.T:Num
} ending fork Declaration for Num
Starting fork { Class op GHC.Num.+ a -> a -> a
} ending fork Class op GHC.Num.+ a -> a -> a
Starting fork { Declaration for sum
Loading decl for Data.List.sum
updating EPS_
Considering whether to load ghc-prim:GHC.Types {- SYSTEM -}
} ending fork Declaration for sum
Starting fork { Declaration for guard
Loading decl for Control.Monad.guard
updating EPS_
Considering whether to load ghc-prim:GHC.Bool {- SYSTEM -}
Reading interface for ghc-prim:GHC.Bool;
    reason: Need home interface for wired-in thing GHC.Bool.Bool
readIFace /home/tora/msr-ghc/ghc-Stack/libraries/ghc-prim/dist/build/GHC/Bool.hi
updating EPS_
Considering whether to load ghc-prim:GHC.Unit {- SYSTEM -}
} ending fork Declaration for guard
Starting fork { Class op GHC.Classes.== a -> a -> GHC.Bool.Bool
Considering whether to load ghc-prim:GHC.Bool {- SYSTEM -}
} ending fork Class op GHC.Classes.== a -> a -> GHC.Bool.Bool
Starting fork { Declaration for Integral
Loading decl for GHC.Real.Integral
updating EPS_
Need decl for GHC.Enum.Enum
Considering whether to load base:GHC.Enum {- SYSTEM -}
Reading interface for base:GHC.Enum;
    reason: Need decl for GHC.Enum.Enum
readIFace /home/tora/msr-ghc/ghc-Stack/libraries/base/dist/build/GHC/Enum.hi
updating EPS_
buildClass
buildClass GHC.Real.T:Integral
} ending fork Declaration for Integral
Starting fork { Class op GHC.Real.mod a -> a -> a
} ending fork Class op GHC.Real.mod a -> a -> a
Starting fork { Class op GHC.Real.div a -> a -> a
} ending fork Class op GHC.Real.div a -> a -> a
Considering whether to load ghc-prim:GHC.Types {- SYSTEM -}
Considering whether to load ghc-prim:GHC.Types {- SYSTEM -}
Starting fork { Declaration for MonadPlus
Loading decl for Control.Monad.MonadPlus
updating EPS_
buildClass
buildClass Control.Monad.T:MonadPlus
} ending fork Declaration for MonadPlus
Starting fork { Class op Control.Monad.mzero forall a. m a
} ending fork Class op Control.Monad.mzero forall a. m a
Starting fork { Declaration for Real
Loading decl for GHC.Real.Real
updating EPS_
buildClass
buildClass GHC.Real.T:Real
} ending fork Declaration for Real
Starting fork { Declaration for Enum
Loading decl for GHC.Enum.Enum
updating EPS_
buildClass
buildClass GHC.Enum.T:Enum
} ending fork Declaration for Enum
Starting fork { Declaration for Ord
Loading decl for GHC.Classes.Ord
updating EPS_
buildClass
buildClass GHC.Classes.T:Ord
} ending fork Declaration for Ord
Starting fork { Dict fun GHC.Num.$f6
Starting fork { Declaration for $f6
Loading decl for GHC.Num.$f6
updating EPS_
Considering whether to load ghc-prim:GHC.Types {- SYSTEM -}
} ending fork Declaration for $f6
} ending fork Dict fun GHC.Num.$f6
Starting fork { Dict fun GHC.Real.$f10
Starting fork { Declaration for $f10
Loading decl for GHC.Real.$f10
updating EPS_
Considering whether to load ghc-prim:GHC.Types {- SYSTEM -}
} ending fork Declaration for $f10
} ending fork Dict fun GHC.Real.$f10
Starting fork { Dict fun MonadState.$f3
Starting fork { Declaration for $f3
Loading decl for MonadState.$f3
updating EPS_
} ending fork Declaration for $f3
} ending fork Dict fun MonadState.$f3
Considering whether to load ghc-prim:GHC.Types {- SYSTEM -}
Starting fork { Class op GHC.Enum.enumFromTo a -> a -> [a]
Considering whether to load ghc-prim:GHC.Types {- SYSTEM -}
} ending fork Class op GHC.Enum.enumFromTo a -> a -> [a]
Starting fork { Dict fun GHC.Enum.$f1
Starting fork { Declaration for $f1
Loading decl for GHC.Enum.$f1
updating EPS_
Considering whether to load ghc-prim:GHC.Types {- SYSTEM -}
} ending fork Declaration for $f1
} ending fork Dict fun GHC.Enum.$f1
Starting fork { Declaration for transpose
Loading decl for Data.List.transpose
updating EPS_
Considering whether to load ghc-prim:GHC.Types {- SYSTEM -}
Considering whether to load ghc-prim:GHC.Types {- SYSTEM -}
Considering whether to load ghc-prim:GHC.Types {- SYSTEM -}
Considering whether to load ghc-prim:GHC.Types {- SYSTEM -}
} ending fork Declaration for transpose
Starting fork { Declaration for map
Loading decl for GHC.Base.map
updating EPS_
Considering whether to load ghc-prim:GHC.Types {- SYSTEM -}
Considering whether to load ghc-prim:GHC.Types {- SYSTEM -}
} ending fork Declaration for map
Starting fork { Declaration for reverse
Loading decl for GHC.List.reverse
updating EPS_
Considering whether to load ghc-prim:GHC.Types {- SYSTEM -}
Considering whether to load ghc-prim:GHC.Types {- SYSTEM -}
} ending fork Declaration for reverse
Starting fork { Declaration for execStateT
Loading decl for MonadState.execStateT
updating EPS_
} ending fork Declaration for execStateT
Considering whether to load ghc-prim:GHC.Types {- SYSTEM -}
Considering whether to load ghc-prim:GHC.Types {- SYSTEM -}
Starting fork { Declaration for fromJust
Loading decl for Data.Maybe.fromJust
updating EPS_
} ending fork Declaration for fromJust
Starting fork { Declaration for foldl
Loading decl for GHC.List.foldl
updating EPS_
Considering whether to load ghc-prim:GHC.Types {- SYSTEM -}
} ending fork Declaration for foldl
Starting fork { Class op GHC.Num.* a -> a -> a
} ending fork Class op GHC.Num.* a -> a -> a
Considering whether to load ghc-prim:GHC.Types {- SYSTEM -}
Starting fork { Class op GHC.Classes.> a -> a -> GHC.Bool.Bool
Considering whether to load ghc-prim:GHC.Bool {- SYSTEM -}
} ending fork Class op GHC.Classes.> a -> a -> GHC.Bool.Bool
Starting fork { Declaration for length
Loading decl for GHC.List.length
updating EPS_
Considering whether to load ghc-prim:GHC.Types {- SYSTEM -}
Considering whether to load ghc-prim:GHC.Types {- SYSTEM -}
} ending fork Declaration for length
Starting fork { Declaration for nub
Loading decl for Data.List.nub
updating EPS_
Considering whether to load ghc-prim:GHC.Types {- SYSTEM -}
Considering whether to load ghc-prim:GHC.Types {- SYSTEM -}
} ending fork Declaration for nub
Starting fork { Declaration for ++
Loading decl for GHC.Base.++
updating EPS_
Considering whether to load ghc-prim:GHC.Types {- SYSTEM -}
Considering whether to load ghc-prim:GHC.Types {- SYSTEM -}
Considering whether to load ghc-prim:GHC.Types {- SYSTEM -}
} ending fork Declaration for ++
Starting fork { Declaration for concat
Loading decl for GHC.List.concat
updating EPS_
Considering whether to load ghc-prim:GHC.Types {- SYSTEM -}
Considering whether to load ghc-prim:GHC.Types {- SYSTEM -}
Considering whether to load ghc-prim:GHC.Types {- SYSTEM -}
} ending fork Declaration for concat
Starting fork { Class op GHC.Classes./= a -> a -> GHC.Bool.Bool
Considering whether to load ghc-prim:GHC.Bool {- SYSTEM -}
} ending fork Class op GHC.Classes./= a -> a -> GHC.Bool.Bool
Starting fork { Declaration for unlines
Loading decl for Data.List.unlines
updating EPS_
Considering whether to load ghc-prim:GHC.Types {- SYSTEM -}
} ending fork Declaration for unlines
Considering whether to load ghc-prim:GHC.Types {- SYSTEM -}
Considering whether to load ghc-prim:GHC.Tuple {- SYSTEM -}
Considering whether to load ghc-prim:GHC.Types {- SYSTEM -}
Starting fork { Class op GHC.Show.show a -> GHC.Base.String
} ending fork Class op GHC.Show.show a -> GHC.Base.String
Starting fork { Dict fun GHC.Base.$f1
Starting fork { Declaration for $f1
Loading decl for GHC.Base.$f1
updating EPS_
Considering whether to load ghc-prim:GHC.Types {- SYSTEM -}
} ending fork Declaration for $f1
} ending fork Dict fun GHC.Base.$f1
tcImportDecl System.IO.putStr
Need decl for System.IO.putStr
Considering whether to load base:System.IO {- SYSTEM -}
Reading interface for base:System.IO;
    reason: Need decl for System.IO.putStr
readIFace /home/tora/msr-ghc/ghc-Stack/libraries/base/dist/build/System/IO.hi
updating EPS_
Starting fork { Declaration for putStr
Loading decl for System.IO.putStr
updating EPS_
Need decl for GHC.IOBase.IO
Considering whether to load base:GHC.IOBase {- SYSTEM -}
Reading interface for base:GHC.IOBase;
    reason: Need decl for GHC.IOBase.IO
readIFace /home/tora/msr-ghc/ghc-Stack/libraries/base/dist/build/GHC/IOBase.hi
updating EPS_
Considering whether to load ghc-prim:GHC.Unit {- SYSTEM -}
} ending fork Declaration for putStr
Considering whether to load ghc-prim:GHC.Types {- SYSTEM -}
Starting fork { Declaration for IO
Loading decl for GHC.IOBase.IO
updating EPS_
mkNewTyConRhs Just GHC.IOBase.NTCo:IO
tcIfaceDecl4 GHC.IOBase.IO
} ending fork Declaration for IO
Starting fork { Class op GHC.Show.showsPrec
                         GHC.Types.Int -> a -> GHC.Show.ShowS
Considering whether to load ghc-prim:GHC.Types {- SYSTEM -}
} ending fork Class op GHC.Show.showsPrec
                       GHC.Types.Int -> a -> GHC.Show.ShowS
Starting fork { Declaration for ShowS
Loading decl for GHC.Show.ShowS
updating EPS_
Starting fork { Type syonym GHC.Show.ShowS
} ending fork Type syonym GHC.Show.ShowS
} ending fork Declaration for ShowS
Starting fork { Declaration for showParen
Loading decl for GHC.Show.showParen
updating EPS_
Considering whether to load ghc-prim:GHC.Bool {- SYSTEM -}
} ending fork Declaration for showParen
Starting fork { Class op GHC.Classes.>= a -> a -> GHC.Bool.Bool
Considering whether to load ghc-prim:GHC.Bool {- SYSTEM -}
} ending fork Class op GHC.Classes.>= a -> a -> GHC.Bool.Bool
Starting fork { Declaration for .
Loading decl for GHC.Base..
updating EPS_
} ending fork Declaration for .
Starting fork { Declaration for showString
Loading decl for GHC.Show.showString
updating EPS_
} ending fork Declaration for showString
Starting fork { Declaration for $dmshow
Loading decl for GHC.Show.$dmshow
updating EPS_
} ending fork Declaration for $dmshow
Starting fork { Class op GHC.Show.showList [a] -> GHC.Show.ShowS
Considering whether to load ghc-prim:GHC.Types {- SYSTEM -}
} ending fork Class op GHC.Show.showList [a] -> GHC.Show.ShowS
Starting fork { Declaration for showList__
Loading decl for GHC.Show.showList__
updating EPS_
Considering whether to load ghc-prim:GHC.Types {- SYSTEM -}
} ending fork Declaration for showList__
tcImportDecl GHC.TopHandler.runMainIO
Need decl for GHC.TopHandler.runMainIO
Considering whether to load base:GHC.TopHandler {- SYSTEM -}
Reading interface for base:GHC.TopHandler;
    reason: Need decl for GHC.TopHandler.runMainIO
readIFace /home/tora/msr-ghc/ghc-Stack/libraries/base/dist/build/GHC/TopHandler.hi
updating EPS_
Starting fork { Declaration for runMainIO
Loading decl for GHC.TopHandler.runMainIO
updating EPS_
} ending fork Declaration for runMainIO
Starting fork { Dict fun Control.Monad.$f2
Starting fork { Declaration for $f2
Loading decl for Control.Monad.$f2
updating EPS_
Considering whether to load ghc-prim:GHC.Types {- SYSTEM -}
} ending fork Declaration for $f2
} ending fork Dict fun Control.Monad.$f2
tcImportDecl GHC.ExplicitCallStack.Stack.Stack
Need decl for GHC.ExplicitCallStack.Stack.Stack
Considering whether to load base:GHC.ExplicitCallStack.Stack {- SYSTEM -}
Reading interface for base:GHC.ExplicitCallStack.Stack;
    reason: Need decl for GHC.ExplicitCallStack.Stack.Stack
readIFace /home/tora/msr-ghc/ghc-Stack/libraries/base/dist/build/GHC/ExplicitCallStack/Stack.hi
updating EPS_
tcImportDecl GHC.Exception.throw
Need decl for GHC.Exception.throw
Considering whether to load base:GHC.Exception {- SYSTEM -}
Reading interface for base:GHC.Exception;
    reason: Need decl for GHC.Exception.throw
readIFace /home/tora/msr-ghc/ghc-Stack/libraries/base/dist/build/GHC/Exception.hi
updating EPS_
Starting fork { Declaration for throwStack
Loading decl for GHC.ExplicitCallStack.Stack.throwStack
updating EPS_
} ending fork Declaration for throwStack
Starting fork { Declaration for unpackCString#
Loading decl for GHC.Base.unpackCString#
updating EPS_
Considering whether to load ghc-prim:GHC.Prim {- SYSTEM -}
Reading interface for ghc-prim:GHC.Prim;
    reason: Need home interface for wired-in thing GHC.Prim.Addr#
updating EPS_
Considering whether to load ghc-prim:GHC.Types {- SYSTEM -}
Considering whether to load ghc-prim:GHC.Types {- SYSTEM -}
} ending fork Declaration for unpackCString#
Starting fork { Declaration for foldr
Loading decl for GHC.Base.foldr
updating EPS_
Considering whether to load ghc-prim:GHC.Types {- SYSTEM -}
} ending fork Declaration for foldr
Starting fork { Declaration for build
Loading decl for GHC.Base.build
updating EPS_
Considering whether to load ghc-prim:GHC.Types {- SYSTEM -}
} ending fork Declaration for build
tcImportDecl MonadState.get_$_debugged
Need decl for MonadState.get_$_debugged
Considering whether to load main:MonadState {- SYSTEM -}
tcImportDecl MonadState.get_$_debugged
Need decl for MonadState.get_$_debugged
Considering whether to load main:MonadState {- SYSTEM -}
tcImportDecl MonadState.get_$_debugged
Need decl for MonadState.get_$_debugged
Considering whether to load main:MonadState {- SYSTEM -}
tcImportDecl MonadState.put_$_debugged
Need decl for MonadState.put_$_debugged
Considering whether to load main:MonadState {- SYSTEM -}
tcImportDecl MonadState.get_$_debugged
Need decl for MonadState.get_$_debugged
Considering whether to load main:MonadState {- SYSTEM -}
tcImportDecl MonadState.put_$_debugged
Need decl for MonadState.put_$_debugged
Considering whether to load main:MonadState {- SYSTEM -}
Starting fork { Declaration for emptyStack
Loading decl for GHC.ExplicitCallStack.Stack.emptyStack
updating EPS_
} ending fork Declaration for emptyStack
Starting fork { Declaration for Stack
Loading decl for GHC.ExplicitCallStack.Stack.Stack
updating EPS_
tcIfaceDecl4 GHC.ExplicitCallStack.Stack.Stack
} ending fork Declaration for Stack
Starting fork { Declaration for pushStack
Loading decl for GHC.ExplicitCallStack.Stack.pushStack
updating EPS_
} ending fork Declaration for pushStack
Starting fork { Declaration for StackElement
Loading decl for GHC.ExplicitCallStack.Stack.StackElement
updating EPS_
tcIfaceDecl4 GHC.ExplicitCallStack.Stack.StackElement
} ending fork Declaration for StackElement
Starting fork { Declaration for mkUnknownStackElem
Loading decl for GHC.ExplicitCallStack.Stack.mkUnknownStackElem
updating EPS_
Considering whether to load ghc-prim:GHC.Types {- SYSTEM -}
Considering whether to load ghc-prim:GHC.Types {- SYSTEM -}
} ending fork Declaration for mkUnknownStackElem
Starting fork { Declaration for $f3_$_debugged
Loading decl for MonadState.$f3_$_debugged
updating EPS_
} ending fork Declaration for $f3_$_debugged
Starting fork { Declaration for mkKnownStackElem
Loading decl for GHC.ExplicitCallStack.Stack.mkKnownStackElem
updating EPS_
Considering whether to load ghc-prim:GHC.Types {- SYSTEM -}
Considering whether to load ghc-prim:GHC.Types {- SYSTEM -}
Considering whether to load ghc-prim:GHC.Types {- SYSTEM -}
Considering whether to load ghc-prim:GHC.Types {- SYSTEM -}
} ending fork Declaration for mkKnownStackElem
Starting fork { Declaration for FilePath
Loading decl for GHC.IOBase.FilePath
updating EPS_
Starting fork { Type syonym GHC.IOBase.FilePath
} ending fork Type syonym GHC.IOBase.FilePath
} ending fork Declaration for FilePath
Starting fork { Declaration for $f2_$_debugged
Loading decl for MonadState.$f2_$_debugged
updating EPS_
} ending fork Declaration for $f2_$_debugged
Starting fork { Declaration for execStateT_$_debugged
Loading decl for MonadState.execStateT_$_debugged
updating EPS_
} ending fork Declaration for execStateT_$_debugged
ghc: panic! (the 'impossible' happened)
  (GHC version 6.11.20090109 for x86_64-unknown-linux):
	Error in core pass Simplifier Phase gentle:
expectJust initTcInteractive: [][Can't find interface-file declaration for variable MonadState.get_$_debugged
  Probable cause: bug in .hi-boot file, or inconsistent .hi file
  Use -ddump-if-trace to get an idea of which file caused the error]

Please report this as a GHC bug:  http://www.haskell.org/ghc/reportabug

<<ghc: 112392608 bytes, 10 GCs, 6567816/13728944 avg/max bytes residency (3 samples), 33M in use, 0.00 INIT (0.00 elapsed), 0.24 MUT (0.70 elapsed), 0.12 GC (0.15 elapsed) :ghc>>
Command exited with non-zero status 1
0.36user 0.17system 0:00.85elapsed 62%CPU (0avgtext+0avgdata 0maxresident)k
0inputs+40outputs (0major+13333minor)pagefaults 0swaps
make: *** [Main.o] Error 1
