==================== Parser ====================
Just let {- rec -}
	 __cmCompileExpr = (System.IO.hSetBuffering System.IO.stdout
						    System.IO.NoBuffering)
			   `Prelude.>>` (System.IO.hSetBuffering System.IO.stderr System.IO.NoBuffering)



==================== Desugared ====================
__letrec {
  >>_azG :: forall a_aqF b_aqH.
	    GHC.IOBase.IO a_aqF -> GHC.IOBase.IO b_aqH -> GHC.IOBase.IO b_aqH
  []
  >>_azG = >>_azH;
  $dMonad_azE :: {GHC.Base.Monad GHC.IOBase.IO}
  []
  $dMonad_azE = $dMonad_azt;
  return_azK :: forall a_azr. a_azr -> GHC.IOBase.IO a_azr
  []
  return_azK = GHC.Base.return @ GHC.IOBase.IO $dMonad_azE;
  $dMonad_azB :: {GHC.Base.Monad GHC.IOBase.IO}
  []
  $dMonad_azB = $dMonad_azt;
  fail_azJ :: forall a_azo. GHC.Base.String -> GHC.IOBase.IO a_azo
  []
  fail_azJ = GHC.Base.fail @ GHC.IOBase.IO $dMonad_azB;
  $dMonad_azy :: {GHC.Base.Monad GHC.IOBase.IO}
  []
  $dMonad_azy = $dMonad_azt;
  >>=_azI :: forall a_azm b_azl.
	     GHC.IOBase.IO a_azm -> (a_azm -> GHC.IOBase.IO b_azl) -> GHC.IOBase.IO b_azl
  []
  >>=_azI = GHC.Base.>>= @ GHC.IOBase.IO $dMonad_azy;
  $dMonad_azt :: {GHC.Base.Monad GHC.IOBase.IO}
  []
  $dMonad_azt = GHC.IOBase.$fMonadIO;
  >>_azH :: forall a_aqF b_aqH.
	    GHC.IOBase.IO a_aqF -> GHC.IOBase.IO b_aqH -> GHC.IOBase.IO b_aqH
  []
  >>_azH = GHC.Base.>> @ GHC.IOBase.IO $dMonad_azt;
} in 
  __letrec {
    __cmCompileExpr_az7 :: GHC.IOBase.IO ()
    []
    __cmCompileExpr_az7 = >>_azG
			    @ ()
			    @ ()
			    (GHC.Handle.hSetBuffering GHC.Handle.stdout GHC.IOBase.NoBuffering)
			    (GHC.Handle.hSetBuffering GHC.Handle.stderr GHC.IOBase.NoBuffering);
    __cmCompileExpr_a1 :: GHC.IOBase.IO ()
    []
    __cmCompileExpr_a1 = __cmCompileExpr_az7;
  } in 
    __letrec {
    } in 
      __letrec {
      } in 
	GHC.IOBase.returnIO
	  @ [()]
	  (GHC.Base.:
	     @ ()
	     (GHC.Prim.unsafeCoerce# @ (GHC.IOBase.IO ()) @ () __cmCompileExpr_a1)
	     (GHC.Base.[] @ ()))



==================== Simplified expression ====================
GHC.IOBase.returnIO
  @ [()]
  (GHC.Base.:
     @ ()
     (__coerce ()
      (GHC.Base.>>
	 @ GHC.IOBase.IO
	 GHC.IOBase.$fMonadIO
	 @ ()
	 @ ()
	 (GHC.Handle.hSetBuffering GHC.Handle.stdout GHC.IOBase.NoBuffering)
	 (GHC.Handle.hSetBuffering GHC.Handle.stderr GHC.IOBase.NoBuffering)))
     (GHC.Base.[] @ ()))



==================== CorePrep ====================
let {
  sat_szQ :: ()
  []
  sat_szQ = let {
	      sat_szO :: GHC.IOBase.IO ()
	      []
	      sat_szO = GHC.Handle.hSetBuffering GHC.Handle.stderr GHC.IOBase.NoBuffering } in
	    let {
	      sat_szM :: GHC.IOBase.IO ()
	      []
	      sat_szM = GHC.Handle.hSetBuffering GHC.Handle.stdout GHC.IOBase.NoBuffering
	    } in 
	      __coerce ()
	      (GHC.Base.>>
		 @ GHC.IOBase.IO GHC.IOBase.$fMonadIO @ () @ () sat_szM sat_szO) } in
let {
  sat_szS :: [()]
  []
  sat_szS = GHC.Base.: @ () sat_szQ (GHC.Base.[] @ ())
} in  GHC.IOBase.returnIO @ [()] sat_szS



==================== Proto-BCOs ====================
ProtoBCO ExprTopLevel_E0#0 []:
      bitmap:  0 []
      ALLOC_AP    0
      PUSH_BCO ProtoBCO sat_szQ#0 []:
		     bitmap:  0 []
		     ALLOC_AP    0
		     PUSH_BCO ProtoBCO sat_szO#0 []:
				    bitmap:  0 []
				    PUSH_G   GHC.IOBase.NoBuffering
				    PUSH_G   GHC.Handle.stderr
				    PUSH_APPLY_PP
				    PUSH_G   GHC.Handle.hSetBuffering
				    ENTER
			      GHC.Handle.hSetBuffering GHC.Handle.stderr GHC.IOBase.NoBuffering
		     MKAP     0 words, 1 stkoff
		     ALLOC_AP    0
		     PUSH_BCO ProtoBCO sat_szM#0 []:
				    bitmap:  0 []
				    PUSH_G   GHC.IOBase.NoBuffering
				    PUSH_G   GHC.Handle.stdout
				    PUSH_APPLY_PP
				    PUSH_G   GHC.Handle.hSetBuffering
				    ENTER
			      GHC.Handle.hSetBuffering GHC.Handle.stdout GHC.IOBase.NoBuffering
		     MKAP     0 words, 1 stkoff
		     PUSH_LL  1 0
		     PUSH_G   GHC.IOBase.$fMonadIO
		     PUSH_APPLY_PPP
		     PUSH_G   GHC.Base.>>
		     SLIDE    5 2
		     ENTER
	       let {
		 sat_szO :: GHC.IOBase.IO ()
		 []
		 sat_szO = GHC.Handle.hSetBuffering GHC.Handle.stderr GHC.IOBase.NoBuffering } in
	       let {
		 sat_szM :: GHC.IOBase.IO ()
		 []
		 sat_szM = GHC.Handle.hSetBuffering GHC.Handle.stdout GHC.IOBase.NoBuffering
	       } in 
		 __coerce ()
		 (GHC.Base.>> @ GHC.IOBase.IO GHC.IOBase.$fMonadIO @ () @ () sat_szM sat_szO)
      MKAP     0 words, 1 stkoff
      PUSH_G   GHC.Base.[]
      PUSH_L   1
      PACK     : 2
      PUSH_L   0
      PUSH_APPLY_P
      PUSH_G   GHC.IOBase.returnIO
      SLIDE    3 2
      ENTER
let {
  sat_szQ :: ()
  []
  sat_szQ = let {
	      sat_szO :: GHC.IOBase.IO ()
	      []
	      sat_szO = GHC.Handle.hSetBuffering GHC.Handle.stderr GHC.IOBase.NoBuffering } in
	    let {
	      sat_szM :: GHC.IOBase.IO ()
	      []
	      sat_szM = GHC.Handle.hSetBuffering GHC.Handle.stdout GHC.IOBase.NoBuffering
	    } in 
	      __coerce ()
	      (GHC.Base.>>
		 @ GHC.IOBase.IO GHC.IOBase.$fMonadIO @ () @ () sat_szM sat_szO) } in
let {
  sat_szS :: [()]
  []
  sat_szS = GHC.Base.: @ () sat_szQ (GHC.Base.[] @ ())
} in  GHC.IOBase.returnIO @ [()] sat_szS


Loading package base-1.0 ... linking ... done.

==================== Parser ====================
Just let {- rec -}
	 __cmCompileExpr = (System.IO.hFlush System.IO.stdout)
			   `Prelude.>>` (System.IO.hFlush IO.stderr)



==================== Desugared ====================
__letrec {
  >>_aAC :: forall a_aqF b_aqH.
	    GHC.IOBase.IO a_aqF -> GHC.IOBase.IO b_aqH -> GHC.IOBase.IO b_aqH
  []
  >>_aAC = >>_aAD;
  $dMonad_aAA :: {GHC.Base.Monad GHC.IOBase.IO}
  []
  $dMonad_aAA = $dMonad_aAp;
  return_aAG :: forall a_azr. a_azr -> GHC.IOBase.IO a_azr
  []
  return_aAG = GHC.Base.return @ GHC.IOBase.IO $dMonad_aAA;
  $dMonad_aAx :: {GHC.Base.Monad GHC.IOBase.IO}
  []
  $dMonad_aAx = $dMonad_aAp;
  fail_aAF :: forall a_azo. GHC.Base.String -> GHC.IOBase.IO a_azo
  []
  fail_aAF = GHC.Base.fail @ GHC.IOBase.IO $dMonad_aAx;
  $dMonad_aAu :: {GHC.Base.Monad GHC.IOBase.IO}
  []
  $dMonad_aAu = $dMonad_aAp;
  >>=_aAE :: forall a_azm b_azl.
	     GHC.IOBase.IO a_azm -> (a_azm -> GHC.IOBase.IO b_azl) -> GHC.IOBase.IO b_azl
  []
  >>=_aAE = GHC.Base.>>= @ GHC.IOBase.IO $dMonad_aAu;
  $dMonad_aAp :: {GHC.Base.Monad GHC.IOBase.IO}
  []
  $dMonad_aAp = GHC.IOBase.$fMonadIO;
  >>_aAD :: forall a_aqF b_aqH.
	    GHC.IOBase.IO a_aqF -> GHC.IOBase.IO b_aqH -> GHC.IOBase.IO b_aqH
  []
  >>_aAD = GHC.Base.>> @ GHC.IOBase.IO $dMonad_aAp;
} in 
  __letrec {
    __cmCompileExpr_aAd :: GHC.IOBase.IO ()
    []
    __cmCompileExpr_aAd = >>_aAC
			    @ ()
			    @ ()
			    (GHC.Handle.hFlush GHC.Handle.stdout)
			    (GHC.Handle.hFlush GHC.Handle.stderr);
    __cmCompileExpr_azU :: GHC.IOBase.IO ()
    []
    __cmCompileExpr_azU = __cmCompileExpr_aAd;
  } in 
    __letrec {
    } in 
      __letrec {
      } in 
	GHC.IOBase.returnIO
	  @ [()]
	  (GHC.Base.:
	     @ ()
	     (GHC.Prim.unsafeCoerce# @ (GHC.IOBase.IO ()) @ () __cmCompileExpr_azU)
	     (GHC.Base.[] @ ()))



==================== Simplified expression ====================
GHC.IOBase.returnIO
  @ [()]
  (GHC.Base.:
     @ ()
     (__coerce ()
      (GHC.Base.>>
	 @ GHC.IOBase.IO
	 GHC.IOBase.$fMonadIO
	 @ ()
	 @ ()
	 (GHC.Handle.hFlush GHC.Handle.stdout)
	 (GHC.Handle.hFlush GHC.Handle.stderr)))
     (GHC.Base.[] @ ()))



==================== CorePrep ====================
let {
  sat_sAM :: ()
  []
  sat_sAM = let {
	      sat_sAK :: GHC.IOBase.IO ()
	      []
	      sat_sAK = GHC.Handle.hFlush GHC.Handle.stderr } in
	    let {
	      sat_sAI :: GHC.IOBase.IO ()
	      []
	      sat_sAI = GHC.Handle.hFlush GHC.Handle.stdout
	    } in 
	      __coerce ()
	      (GHC.Base.>>
		 @ GHC.IOBase.IO GHC.IOBase.$fMonadIO @ () @ () sat_sAI sat_sAK) } in
let {
  sat_sAO :: [()]
  []
  sat_sAO = GHC.Base.: @ () sat_sAM (GHC.Base.[] @ ())
} in  GHC.IOBase.returnIO @ [()] sat_sAO



==================== Proto-BCOs ====================
ProtoBCO ExprTopLevel_E0#0 []:
      bitmap:  0 []
      ALLOC_AP    0
      PUSH_BCO ProtoBCO sat_sAM#0 []:
		     bitmap:  0 []
		     ALLOC_AP    0
		     PUSH_BCO ProtoBCO sat_sAK#0 []:
				    bitmap:  0 []
				    PUSH_G   GHC.Handle.stderr
				    PUSH_APPLY_P
				    PUSH_G   GHC.Handle.hFlush
				    ENTER
			      GHC.Handle.hFlush GHC.Handle.stderr
		     MKAP     0 words, 1 stkoff
		     ALLOC_AP    0
		     PUSH_BCO ProtoBCO sat_sAI#0 []:
				    bitmap:  0 []
				    PUSH_G   GHC.Handle.stdout
				    PUSH_APPLY_P
				    PUSH_G   GHC.Handle.hFlush
				    ENTER
			      GHC.Handle.hFlush GHC.Handle.stdout
		     MKAP     0 words, 1 stkoff
		     PUSH_LL  1 0
		     PUSH_G   GHC.IOBase.$fMonadIO
		     PUSH_APPLY_PPP
		     PUSH_G   GHC.Base.>>
		     SLIDE    5 2
		     ENTER
	       let {
		 sat_sAK :: GHC.IOBase.IO ()
		 []
		 sat_sAK = GHC.Handle.hFlush GHC.Handle.stderr } in
	       let {
		 sat_sAI :: GHC.IOBase.IO ()
		 []
		 sat_sAI = GHC.Handle.hFlush GHC.Handle.stdout
	       } in 
		 __coerce ()
		 (GHC.Base.>> @ GHC.IOBase.IO GHC.IOBase.$fMonadIO @ () @ () sat_sAI sat_sAK)
      MKAP     0 words, 1 stkoff
      PUSH_G   GHC.Base.[]
      PUSH_L   1
      PACK     : 2
      PUSH_L   0
      PUSH_APPLY_P
      PUSH_G   GHC.IOBase.returnIO
      SLIDE    3 2
      ENTER
let {
  sat_sAM :: ()
  []
  sat_sAM = let {
	      sat_sAK :: GHC.IOBase.IO ()
	      []
	      sat_sAK = GHC.Handle.hFlush GHC.Handle.stderr } in
	    let {
	      sat_sAI :: GHC.IOBase.IO ()
	      []
	      sat_sAI = GHC.Handle.hFlush GHC.Handle.stdout
	    } in 
	      __coerce ()
	      (GHC.Base.>>
		 @ GHC.IOBase.IO GHC.IOBase.$fMonadIO @ () @ () sat_sAI sat_sAK) } in
let {
  sat_sAO :: [()]
  []
  sat_sAO = GHC.Base.: @ () sat_sAM (GHC.Base.[] @ ())
} in  GHC.IOBase.returnIO @ [()] sat_sAO



==================== Parser ====================
import Distribution.Simple
main = do defaultMain



==================== Source Statistics ====================
ExportAll        1
Imports          1
  ImpAll         1
FunBinds         1



==================== Derived instances ====================



==================== Desugar ====================
Rec {
:Main.main :: GHC.IOBase.IO ()
[Exported]
[]
:Main.main = GHC.TopHandler.runMainIO @ () Main.main
main_a1Hj :: GHC.IOBase.IO ()
[]
main_a1Hj = Distribution.Simple.defaultMain
$dMonad_a1HK :: {GHC.Base.Monad GHC.IOBase.IO}
[]
$dMonad_a1HK = $dMonad_a1Hz
return_a1Il :: forall a_azr. a_azr -> GHC.IOBase.IO a_azr
[]
return_a1Il = GHC.Base.return @ GHC.IOBase.IO $dMonad_a1HK
$dMonad_a1HH :: {GHC.Base.Monad GHC.IOBase.IO}
[]
$dMonad_a1HH = $dMonad_a1Hz
fail_a1Ik :: forall a_azo. GHC.Base.String -> GHC.IOBase.IO a_azo
[]
fail_a1Ik = GHC.Base.fail @ GHC.IOBase.IO $dMonad_a1HH
$dMonad_a1HE :: {GHC.Base.Monad GHC.IOBase.IO}
[]
$dMonad_a1HE = $dMonad_a1Hz
>>=_a1Ij :: forall a_azm b_azl.
	    GHC.IOBase.IO a_azm -> (a_azm -> GHC.IOBase.IO b_azl) -> GHC.IOBase.IO b_azl
[]
>>=_a1Ij = GHC.Base.>>= @ GHC.IOBase.IO $dMonad_a1HE
$dMonad_a1Hz :: {GHC.Base.Monad GHC.IOBase.IO}
[]
$dMonad_a1Hz = GHC.IOBase.$fMonadIO
>>_a1Ii :: forall a_aqF b_aqH.
	   GHC.IOBase.IO a_aqF -> GHC.IOBase.IO b_aqH -> GHC.IOBase.IO b_aqH
[]
>>_a1Ii = GHC.Base.>> @ GHC.IOBase.IO $dMonad_a1Hz
Main.main :: GHC.IOBase.IO ()
[Exported]
[]
Main.main = main_a1Hj
end Rec }




==================== Transformation rules ====================
Local rules

Imported rules



==================== Occurrence analysis ====================
main_a1Hj :: GHC.IOBase.IO ()
[]
main_a1Hj = Distribution.Simple.defaultMain

Main.main :: GHC.IOBase.IO ()
[Exported]
[]
Main.main = main_a1Hj

:Main.main :: GHC.IOBase.IO ()
[Exported]
[]
:Main.main = GHC.TopHandler.runMainIO @ () Main.main




==================== Simplifier phase 0, iteration 1 out of 4 ====================
Total ticks: NON-ZERO!



==================== Simplifier phase 0, iteration 1 out of 4 ====================
Main.main :: GHC.IOBase.IO ()
[Exported]
[]
Main.main = Distribution.Simple.defaultMain

:Main.main :: GHC.IOBase.IO ()
[Exported]
[]
:Main.main = GHC.TopHandler.runMainIO @ () Distribution.Simple.defaultMain




==================== Occurrence analysis ====================
Main.main :: GHC.IOBase.IO ()
[Exported]
[]
Main.main = Distribution.Simple.defaultMain

:Main.main :: GHC.IOBase.IO ()
[Exported]
[]
:Main.main = GHC.TopHandler.runMainIO @ () Distribution.Simple.defaultMain




==================== Simplify ====================
Main.main :: GHC.IOBase.IO ()
[Exported]
[]
Main.main = Distribution.Simple.defaultMain

:Main.main :: GHC.IOBase.IO ()
[Exported]
[]
:Main.main = GHC.TopHandler.runMainIO @ () Distribution.Simple.defaultMain




==================== Grand total simplifier statistics ====================
Total ticks: NON-ZERO!



==================== Tidy Core ====================
Main.main :: GHC.IOBase.IO ()
[GlobalId]
[]
Main.main = Distribution.Simple.defaultMain

:Main.main :: GHC.IOBase.IO ()
[GlobalId]
[]
:Main.main = GHC.TopHandler.runMainIO @ () Distribution.Simple.defaultMain




==================== Tidy Core Rules ====================



==================== FINAL INTERFACE ====================
interface Main 1 6041 where
export Main main
module dependencies:
package dependencies: Cabal-1.0 base-1.0
orphans: Foreign.C.Types Foreign.Ptr GHC.Base GHC.Float GHC.Int GHC.List
	 GHC.Word
main :: GHC.IOBase.IO ()
main :: GHC.IOBase.IO ()



==================== CorePrep ====================
Main.main :: GHC.IOBase.IO ()
[GlobalId]
[]
Main.main = Distribution.Simple.defaultMain

:Main.main :: GHC.IOBase.IO ()
[GlobalId]
[]
:Main.main = GHC.TopHandler.runMainIO @ () Distribution.Simple.defaultMain




==================== Proto-BCOs ====================
ProtoBCO Main.main#0 []:
      bitmap:  0 []
      PUSH_G   Distribution.Simple.defaultMain
      ENTER
Distribution.Simple.defaultMain
 
ProtoBCO :Main.main#0 []:
      bitmap:  0 []
      PUSH_G   Distribution.Simple.defaultMain
      PUSH_APPLY_P
      PUSH_G   GHC.TopHandler.runMainIO
      ENTER
GHC.TopHandler.runMainIO @ () Distribution.Simple.defaultMain


Ok, modules loaded: Main.

==================== Parser ====================
Just System.Environment.withProgName "Setup.hs"
				     (System.Environment.withArgs ["build"] Main.main)



==================== Desugared ====================
__letrec {
  $dMonad_a1Jm :: {GHC.Base.Monad GHC.IOBase.IO}
  []
  $dMonad_a1Jm = $dMonad_a1Jb;
  return_a1Jr :: forall a_azr. a_azr -> GHC.IOBase.IO a_azr
  []
  return_a1Jr = GHC.Base.return @ GHC.IOBase.IO $dMonad_a1Jm;
  $dMonad_a1Jj :: {GHC.Base.Monad GHC.IOBase.IO}
  []
  $dMonad_a1Jj = $dMonad_a1Jb;
  fail_a1Jq :: forall a_azo. GHC.Base.String -> GHC.IOBase.IO a_azo
  []
  fail_a1Jq = GHC.Base.fail @ GHC.IOBase.IO $dMonad_a1Jj;
  $dMonad_a1Jg :: {GHC.Base.Monad GHC.IOBase.IO}
  []
  $dMonad_a1Jg = $dMonad_a1Jb;
  >>=_a1Jp :: forall a_azm b_azl.
	      GHC.IOBase.IO a_azm -> (a_azm -> GHC.IOBase.IO b_azl) -> GHC.IOBase.IO b_azl
  []
  >>=_a1Jp = GHC.Base.>>= @ GHC.IOBase.IO $dMonad_a1Jg;
  $dMonad_a1Jb :: {GHC.Base.Monad GHC.IOBase.IO}
  []
  $dMonad_a1Jb = GHC.IOBase.$fMonadIO;
  >>_a1Jo :: forall a_aqF b_aqH.
	     GHC.IOBase.IO a_aqF -> GHC.IOBase.IO b_aqH -> GHC.IOBase.IO b_aqH
  []
  >>_a1Jo = GHC.Base.>> @ GHC.IOBase.IO $dMonad_a1Jb;
} in 
  >>=_a1Jp
    @ ()
    @ [()]
    (System.Environment.withProgName
       @ ()
       (GHC.Base.unpackCString# "Setup.hs")
       (System.Environment.withArgs
	  @ ()
	  (GHC.Base.:
	     @ GHC.Base.String
	     (GHC.Base.unpackCString# "build")
	     (GHC.Base.[] @ GHC.Base.String))
	  Main.main))
    (\ (it_a1J5 :: ()) ->
       GHC.IOBase.returnIO
	 @ [()]
	 (GHC.Base.: @ () (GHC.Prim.unsafeCoerce# @ () @ () it_a1J5) (GHC.Base.[] @ ())))



==================== Simplified expression ====================
GHC.Base.>>=
  @ GHC.IOBase.IO
  GHC.IOBase.$fMonadIO
  @ ()
  @ [()]
  (System.Environment.withProgName
     @ ()
     (GHC.Base.unpackCString# "Setup.hs")
     (System.Environment.withArgs
	@ ()
	(GHC.Base.:
	   @ GHC.Base.String
	   (GHC.Base.unpackCString# "build")
	   (GHC.Base.[] @ GHC.Base.String))
	Main.main))
  (\ (it_a1J5 :: ()) ->
     GHC.IOBase.returnIO @ [()] (GHC.Base.: @ () it_a1J5 (GHC.Base.[] @ ())))



==================== CorePrep ====================
let {
  sat_s1JK :: () -> GHC.IOBase.IO [()]
  []
  sat_s1JK = \ (it_s1JF :: ()) ->
	       let {
		 sat_s1JH :: [()]
		 []
		 sat_s1JH = GHC.Base.: @ () it_s1JF (GHC.Base.[] @ ())
	       } in  GHC.IOBase.returnIO @ [()] sat_s1JH } in
let {
  sat_s1JD :: GHC.IOBase.IO ()
  []
  sat_s1JD = let {
	       sat_s1JB :: GHC.IOBase.IO ()
	       []
	       sat_s1JB = let {
			    sat_s1Jx :: [GHC.Base.Char]
			    []
			    sat_s1Jx = GHC.Base.unpackCString# "build" } in
			  let {
			    sat_s1Jz :: [GHC.Base.String]
			    []
			    sat_s1Jz = GHC.Base.: @ GHC.Base.String sat_s1Jx (GHC.Base.[] @ GHC.Base.String)
			  } in  System.Environment.withArgs @ () sat_s1Jz Main.main } in
	     let {
	       sat_s1Jv :: [GHC.Base.Char]
	       []
	       sat_s1Jv = GHC.Base.unpackCString# "Setup.hs"
	     } in  System.Environment.withProgName @ () sat_s1Jv sat_s1JB
} in 
  GHC.Base.>>= @ GHC.IOBase.IO GHC.IOBase.$fMonadIO @ () @ [()] sat_s1JD sat_s1JK



==================== Proto-BCOs ====================
ProtoBCO ExprTopLevel_E0#0 []:
      bitmap:  0 []
      ALLOC_PAP    1 0
      PUSH_BCO ProtoBCO sat_s1JK#1 []:
		     bitmap:  1 [0]
		     PUSH_G   GHC.Base.[]
		     PUSH_L   1
		     PACK     : 2
		     PUSH_L   0
		     PUSH_APPLY_P
		     PUSH_G   GHC.IOBase.returnIO
		     SLIDE    3 2
		     ENTER
	       \ (it_s1JF :: ()) ->
		 let {
		   sat_s1JH :: [()]
		   []
		   sat_s1JH = GHC.Base.: @ () it_s1JF (GHC.Base.[] @ ())
		 } in  GHC.IOBase.returnIO @ [()] sat_s1JH
      MKAP     0 words, 1 stkoff
      ALLOC_AP    0
      PUSH_BCO ProtoBCO sat_s1JD#0 []:
		     bitmap:  0 []
		     ALLOC_AP    0
		     PUSH_BCO ProtoBCO sat_s1JB#0 []:
				    bitmap:  0 []
				    ALLOC_AP    0
				    PUSH_BCO ProtoBCO sat_s1Jx#0 [0x003dfe80]:
						   bitmap:  0 []
						   PUSH_UBX (1) 0x003dfe80
						   PUSH_APPLY_N
						   PUSH_G   GHC.Base.unpackCString#
						   ENTER
					     GHC.Base.unpackCString# "build"
				    MKAP     0 words, 1 stkoff
				    PUSH_G   GHC.Base.[]
				    PUSH_L   1
				    PACK     : 2
				    PUSH_G   Main.main
				    PUSH_L   1
				    PUSH_APPLY_PP
				    PUSH_G   System.Environment.withArgs
				    SLIDE    4 2
				    ENTER
			      let {
				sat_s1Jx :: [GHC.Base.Char]
				[]
				sat_s1Jx = GHC.Base.unpackCString# "build" } in
			      let {
				sat_s1Jz :: [GHC.Base.String]
				[]
				sat_s1Jz = GHC.Base.: @ GHC.Base.String sat_s1Jx (GHC.Base.[] @ GHC.Base.String)
			      } in  System.Environment.withArgs @ () sat_s1Jz Main.main
		     MKAP     0 words, 1 stkoff
		     ALLOC_AP    0
		     PUSH_BCO ProtoBCO sat_s1Jv#0 [0x003dfe68]:
				    bitmap:  0 []
				    PUSH_UBX (1) 0x003dfe68
				    PUSH_APPLY_N
				    PUSH_G   GHC.Base.unpackCString#
				    ENTER
			      GHC.Base.unpackCString# "Setup.hs"
		     MKAP     0 words, 1 stkoff
		     PUSH_LL  1 0
		     PUSH_APPLY_PP
		     PUSH_G   System.Environment.withProgName
		     SLIDE    4 2
		     ENTER
	       let {
		 sat_s1JB :: GHC.IOBase.IO ()
		 []
		 sat_s1JB = let {
			      sat_s1Jx :: [GHC.Base.Char]
			      []
			      sat_s1Jx = GHC.Base.unpackCString# "build" } in
			    let {
			      sat_s1Jz :: [GHC.Base.String]
			      []
			      sat_s1Jz = GHC.Base.: @ GHC.Base.String sat_s1Jx (GHC.Base.[] @ GHC.Base.String)
			    } in  System.Environment.withArgs @ () sat_s1Jz Main.main } in
	       let {
		 sat_s1Jv :: [GHC.Base.Char]
		 []
		 sat_s1Jv = GHC.Base.unpackCString# "Setup.hs"
	       } in  System.Environment.withProgName @ () sat_s1Jv sat_s1JB
      MKAP     0 words, 1 stkoff
      PUSH_LL  1 0
      PUSH_G   GHC.IOBase.$fMonadIO
      PUSH_APPLY_PPP
      PUSH_G   GHC.Base.>>=
      SLIDE    5 2
      ENTER
let {
  sat_s1JK :: () -> GHC.IOBase.IO [()]
  []
  sat_s1JK = \ (it_s1JF :: ()) ->
	       let {
		 sat_s1JH :: [()]
		 []
		 sat_s1JH = GHC.Base.: @ () it_s1JF (GHC.Base.[] @ ())
	       } in  GHC.IOBase.returnIO @ [()] sat_s1JH } in
let {
  sat_s1JD :: GHC.IOBase.IO ()
  []
  sat_s1JD = let {
	       sat_s1JB :: GHC.IOBase.IO ()
	       []
	       sat_s1JB = let {
			    sat_s1Jx :: [GHC.Base.Char]
			    []
			    sat_s1Jx = GHC.Base.unpackCString# "build" } in
			  let {
			    sat_s1Jz :: [GHC.Base.String]
			    []
			    sat_s1Jz = GHC.Base.: @ GHC.Base.String sat_s1Jx (GHC.Base.[] @ GHC.Base.String)
			  } in  System.Environment.withArgs @ () sat_s1Jz Main.main } in
	     let {
	       sat_s1Jv :: [GHC.Base.Char]
	       []
	       sat_s1Jv = GHC.Base.unpackCString# "Setup.hs"
	     } in  System.Environment.withProgName @ () sat_s1Jv sat_s1JB
} in 
  GHC.Base.>>= @ GHC.IOBase.IO GHC.IOBase.$fMonadIO @ () @ [()] sat_s1JD sat_s1JK


Loading package Cabal-1.0 ... linking ... done.
Preprocessing library Vasicek-0.3...
Building Vasicek-0.3...