T5331.bad.dump-simpl

==================== Tidy Core ====================
2015-07-07 10:14:07.062832 UTC

Result size of Tidy Core = {terms: 448, types: 377, coercions: 15}

Main.main3 :: [Char]
[GblId,
 Str=DmdType,
 Unf=Unf{Src=<vanilla>, TopLvl=True, Value=False, ConLike=False,
         WorkFree=False, Expandable=False, Guidance=IF_ARGS [] 40 0}]
Main.main3 = GHC.CString.unpackCString# ")"#

Main.main4 :: [Char]
[GblId,
 Str=DmdType,
 Unf=Unf{Src=<vanilla>, TopLvl=True, Value=False, ConLike=False,
         WorkFree=False, Expandable=False, Guidance=IF_ARGS [] 40 0}]
Main.main4 = GHC.CString.unpackCString# "Int"#

isqrt :: Int -> Int
[GblId,
 Arity=1,
 Caf=NoCafRefs,
 Str=DmdType <S,1*U(U)>m,
 Unf=Unf{Src=InlineStable, TopLvl=True, Value=True, ConLike=True,
         WorkFree=True, Expandable=True,
         Guidance=ALWAYS_IF(arity=1,unsat_ok=True,boring_ok=False)
         Tmpl= \ (n_aGY [Occ=Once!] :: Int) ->
                 case n_aGY of _ [Occ=Dead] { GHC.Types.I# i_a2GV [Occ=Once] ->
                 let {
                   x_a2H4 :: GHC.Prim.Double#
                   [LclId, Str=DmdType]
                   x_a2H4 = GHC.Prim.sqrtDouble# (GHC.Prim.int2Double# i_a2GV) } in
                 let {
                   n1_a2H3 :: GHC.Prim.Int#
                   [LclId, Str=DmdType]
                   n1_a2H3 = GHC.Prim.double2Int# x_a2H4 } in
                 case GHC.Prim.tagToEnum#
                        @ Bool (GHC.Prim.<## x_a2H4 (GHC.Prim.int2Double# n1_a2H3))
                 of _ [Occ=Dead] {
                   False -> GHC.Types.I# n1_a2H3;
                   True -> GHC.Types.I# (GHC.Prim.-# n1_a2H3 1)
                 }
                 }}]
isqrt =
  \ (n_aGY :: Int) ->
    case n_aGY of _ [Occ=Dead] { GHC.Types.I# i_a2GV ->
    let {
      x_a2H4 :: GHC.Prim.Double#
      [LclId, Str=DmdType]
      x_a2H4 = GHC.Prim.sqrtDouble# (GHC.Prim.int2Double# i_a2GV) } in
    let {
      n1_a2H3 :: GHC.Prim.Int#
      [LclId, Str=DmdType]
      n1_a2H3 = GHC.Prim.double2Int# x_a2H4 } in
    case GHC.Prim.tagToEnum#
           @ Bool (GHC.Prim.<## x_a2H4 (GHC.Prim.int2Double# n1_a2H3))
    of _ [Occ=Dead] {
      False -> GHC.Types.I# n1_a2H3;
      True -> GHC.Types.I# (GHC.Prim.-# n1_a2H3 1)
    }
    }

poly_$dApplicative_r54y :: forall s_a1fk. Applicative (ST s_a1fk)
[GblId, Str=DmdType]
poly_$dApplicative_r54y =
  \ (@ s_a1fk) ->
    GHC.ST.$fApplicativeST @ s_a1fk (GHC.ST.$fFunctorST @ s_a1fk)

poly_$dMonad_r54z :: forall s_a1fk. Monad (ST s_a1fk)
[GblId, Str=DmdType]
poly_$dMonad_r54z =
  \ (@ s_a1fk) ->
    GHC.ST.$fMonadST @ s_a1fk (poly_$dApplicative_r54y @ s_a1fk)

poly_$dMArray_r54A
  :: forall s_a1fk. MArray (STUArray s_a1fk) Int (ST s_a1fk)
[GblId, Str=DmdType]
poly_$dMArray_r54A =
  \ (@ s_a1fk) ->
    Data.Array.Base.$fMArraySTUArrayIntST
      @ s_a1fk (poly_$dMonad_r54z @ s_a1fk)

lvl2_r54B :: Int
[GblId, Caf=NoCafRefs, Str=DmdType m]
lvl2_r54B = GHC.Types.I# 0

lvl3_r54C :: Int
[GblId, Caf=NoCafRefs, Str=DmdType m]
lvl3_r54C = GHC.Types.I# 2

lvl4_r54D :: [Char]
[GblId, Str=DmdType]
lvl4_r54D = GHC.CString.unpackCString# "Negative range size"#

Main.$wdivisorCounts [InlPrag=[0]]
  :: GHC.Prim.Int# -> UArray Int Int
[GblId, Arity=1, Str=DmdType <L,U>]
Main.$wdivisorCounts =
  \ (ww_s4Yy :: GHC.Prim.Int#) ->
    GHC.ST.runSTRep
      @ (UArray Int Int)
      (\ (@ s_a2xr) (s1_a2xs [OS=OneShot] :: GHC.Prim.State# s_a2xr) ->
         let {
           x_a2H4 :: GHC.Prim.Double#
           [LclId, Str=DmdType]
           x_a2H4 = GHC.Prim.sqrtDouble# (GHC.Prim.int2Double# ww_s4Yy) } in
         let {
           n_a2H3 :: GHC.Prim.Int#
           [LclId, Str=DmdType]
           n_a2H3 = GHC.Prim.double2Int# x_a2H4 } in
         let {
           $j_s4MD
             :: GHC.Prim.Int# -> (# GHC.Prim.State# s_a2xr, UArray Int Int #)
           [LclId, Arity=1, Str=DmdType <L,U>]
           $j_s4MD =
             \ (ipv_s2Hm [OS=OneShot] :: GHC.Prim.Int#) ->
               let {
                 $w$j_s4Yt [InlPrag=[0]]
                   :: GHC.Prim.State# s_a2xr
                      -> Int
                      -> Int
                      -> GHC.Prim.Int#
                      -> GHC.Prim.MutableByteArray# s_a2xr
                      -> (# GHC.Prim.State# s_a2xr, UArray Int Int #)
                 [LclId, Arity=5, Str=DmdType <L,U><S,U><S,U><L,U><L,U>]
                 $w$j_s4Yt =
                   \ (w_s4Yk [OS=OneShot] :: GHC.Prim.State# s_a2xr)
                     (ww1_s4Yo [OS=OneShot] :: Int)
                     (ww2_s4Yp [OS=OneShot] :: Int)
                     (ww3_s4Yq [OS=OneShot] :: GHC.Prim.Int#)
                     (ww4_s4Yr [OS=OneShot] :: GHC.Prim.MutableByteArray# s_a2xr) ->
                     let {
                       $j1_s4Mw
                         :: GHC.Prim.Int# -> (# GHC.Prim.State# s_a2xr, UArray Int Int #)
                       [LclId, Arity=1, Str=DmdType <L,U>]
                       $j1_s4Mw =
                         \ (x1_a2Tq [OS=OneShot] :: GHC.Prim.Int#) ->
                           let {
                             y_a2Z2 :: GHC.Prim.Int#
                             [LclId, Str=DmdType]
                             y_a2Z2 = GHC.Prim.-# x1_a2Tq 1 } in
                           let {
                             $w$j1_s4Y6 [InlPrag=[0]]
                               :: GHC.Prim.State# s_a2xr
                                  -> (# GHC.Prim.State# s_a2xr, UArray Int Int #)
                             [LclId, Arity=1, Str=DmdType <L,U>]
                             $w$j1_s4Y6 =
                               \ (w1_s4Y4 [OS=OneShot] :: GHC.Prim.State# s_a2xr) ->
                                 let {
                                   ipv1_a2Q5 :: STUArray s_a2xr Int Int
                                   [LclId, Str=DmdType]
                                   ipv1_a2Q5 =
                                     Data.Array.Base.STUArray
                                       @ s_a2xr @ Int @ Int ww1_s4Yo ww2_s4Yp ww3_s4Yq ww4_s4Yr } in
                                 let {
                                   $wnote_s4XW [InlPrag=[0]]
                                     :: forall (m_a29f :: * -> *).
                                        MArray (STUArray s_a2xr) Int m_a29f =>
                                        Int -> GHC.Prim.Int# -> m_a29f ()
                                   [LclId,
                                    Arity=3,
                                    Str=DmdType <S(SLLLLLLL),U(U,A,A,A,A,A,C(C1(C1(U))),C(C1(C1(C1(U)))))><L,U(U)><L,U>]
                                   $wnote_s4XW =
                                     \ (@ (m_a29f :: * -> *))
                                       (w2_s4XP :: MArray (STUArray s_a2xr) Int m_a29f)
                                       (w3_s4XQ [OS=OneShot] :: Int)
                                       (ww5_s4XU [OS=OneShot] :: GHC.Prim.Int#) ->
                                       let {
                                         $dMonad_s2QU [Dmd=<S,U(U,U,C(C(U)),C(U),U)>]
                                           :: Monad m_a29f
                                         [LclId, Str=DmdType]
                                         $dMonad_s2QU =
                                           Data.Array.Base.$p1MArray
                                             @ (STUArray s_a2xr) @ Int @ m_a29f w2_s4XP } in
                                       let {
                                         lvl5_s2RW :: m_a29f ()
                                         [LclId, Str=DmdType]
                                         lvl5_s2RW =
                                           return @ m_a29f $dMonad_s2QU @ () GHC.Tuple.() } in
                                       letrec {
                                         $wnote1_s4XO [InlPrag=[0], Occ=LoopBreaker]
                                           :: Int -> GHC.Prim.Int# -> m_a29f ()
                                         [LclId, Arity=2, Str=DmdType <L,U(U)><L,U>]
                                         $wnote1_s4XO =
                                           \ (w4_s4XI :: Int) (ww6_s4XM :: GHC.Prim.Int#) ->
                                             case GHC.Prim.tagToEnum#
                                                    @ Bool (GHC.Prim.># ww6_s4XM ww_s4Yy)
                                             of _ [Occ=Dead] {
                                               False ->
                                                 >>
                                                   @ m_a29f
                                                   $dMonad_s2QU
                                                   @ ()
                                                   @ ()
                                                   (let {
                                                      wild1_a2OZ :: Int
                                                      [LclId, Str=DmdType]
                                                      wild1_a2OZ = GHC.Types.I# ww6_s4XM } in
                                                    >>=
                                                      @ m_a29f
                                                      $dMonad_s2QU
                                                      @ Int
                                                      @ ()
                                                      (unsafeRead
                                                         @ (STUArray s_a2xr)
                                                         @ Int
                                                         @ m_a29f
                                                         w2_s4XP
                                                         @ Int
                                                         GHC.Arr.$fIxInt
                                                         ipv1_a2Q5
                                                         wild1_a2OZ)
                                                      (\ (k_aRm :: Int) ->
                                                         unsafeWrite
                                                           @ (STUArray s_a2xr)
                                                           @ Int
                                                           @ m_a29f
                                                           w2_s4XP
                                                           @ Int
                                                           GHC.Arr.$fIxInt
                                                           ipv1_a2Q5
                                                           wild1_a2OZ
                                                           (case k_aRm
                                                            of _ [Occ=Dead]
                                                            { GHC.Types.I# x2_a2Pi ->
                                                            GHC.Types.I# (GHC.Prim.+# x2_a2Pi 1)
                                                            })))
                                                   (case w4_s4XI
                                                    of wild1_a2Pk { GHC.Types.I# y1_a2Pm ->
                                                    $wnote1_s4XO
                                                      wild1_a2Pk (GHC.Prim.+# ww6_s4XM y1_a2Pm)
                                                    });
                                               True -> lvl5_s2RW
                                             }; } in
                                       $wnote1_s4XO w3_s4XQ ww5_s4XU } in
                                 case (($wnote_s4XW
                                          @ (ST s_a2xr) (poly_$dMArray_r54A @ s_a2xr) lvl3_r54C 4)
                                       `cast` (GHC.ST.NTCo:ST[0] <s_a2xr>_N <()>_R
                                               :: ST s_a2xr () ~R# GHC.ST.STRep s_a2xr ()))
                                        w1_s4Y4
                                 of _ [Occ=Dead] { (# ipv2_X2Rp, ipv3_X2Rr #) ->
                                 letrec {
                                   $wa_s4Y3 [InlPrag=[0], Occ=LoopBreaker]
                                     :: GHC.Prim.Int#
                                        -> GHC.Prim.State# s_a2xr
                                        -> (# GHC.Prim.State# s_a2xr, () #)
                                   [LclId, Arity=2, Str=DmdType <L,U><L,U>]
                                   $wa_s4Y3 =
                                     \ (ww5_s4Y1 :: GHC.Prim.Int#)
                                       (w2_s4XY [OS=OneShot] :: GHC.Prim.State# s_a2xr) ->
                                       case GHC.Prim.tagToEnum#
                                              @ Bool (GHC.Prim.># ww5_s4Y1 ipv_s2Hm)
                                       of _ [Occ=Dead] {
                                         False ->
                                           case (($wnote_s4XW
                                                    @ (ST s_a2xr)
                                                    (poly_$dMArray_r54A @ s_a2xr)
                                                    (GHC.Types.I# (GHC.Prim.*# 2 ww5_s4Y1))
                                                    (GHC.Prim.*# ww5_s4Y1 ww5_s4Y1))
                                                 `cast` (GHC.ST.NTCo:ST[0] <s_a2xr>_N <()>_R
                                                         :: ST s_a2xr ()
                                                            ~R# GHC.ST.STRep s_a2xr ()))
                                                  w2_s4XY
                                           of _ [Occ=Dead] { (# ipv4_X2Ty, ipv5_X2RF #) ->
                                           $wa_s4Y3 (GHC.Prim.+# ww5_s4Y1 2) ipv4_X2Ty
                                           };
                                         True -> (# w2_s4XY, GHC.Tuple.() #)
                                       }; } in
                                 case $wa_s4Y3 3 ipv2_X2Rp
                                 of _ [Occ=Dead] { (# ipv4_X2Rv, ipv5_X2Rx #) ->
                                 case GHC.Prim.unsafeFreezeByteArray# @ s_a2xr ww4_s4Yr ipv4_X2Rv
                                 of _ [Occ=Dead] { (# ipv6_a2xM, ipv7_a2xN #) ->
                                 (# ipv6_a2xM,
                                    Data.Array.Base.UArray
                                      @ Int @ Int ww1_s4Yo ww2_s4Yp ww3_s4Yq ipv7_a2xN #)
                                 }
                                 }
                                 } } in
                           case GHC.Prim.tagToEnum# @ Bool (GHC.Prim.># 0 y_a2Z2)
                           of _ [Occ=Dead] {
                             False ->
                               letrec {
                                 a_s4SV [Occ=LoopBreaker]
                                   :: GHC.Prim.Int#
                                      -> GHC.Prim.State# s_a2xr -> (# GHC.Prim.State# s_a2xr, () #)
                                 [LclId, Arity=2, Str=DmdType <L,U><L,U>]
                                 a_s4SV =
                                   \ (x2_a2Z6 :: GHC.Prim.Int#)
                                     (s2_X2S5 [OS=OneShot] :: GHC.Prim.State# s_a2xr) ->
                                     case GHC.Prim.writeIntArray#
                                            @ s_a2xr ww4_s4Yr x2_a2Z6 1 s2_X2S5
                                     of s2#_a2OO [OS=OneShot] { __DEFAULT ->
                                     case GHC.Prim.tagToEnum# @ Bool (GHC.Prim.==# x2_a2Z6 y_a2Z2)
                                     of _ [Occ=Dead] {
                                       False -> a_s4SV (GHC.Prim.+# x2_a2Z6 1) s2#_a2OO;
                                       True -> (# s2#_a2OO, GHC.Tuple.() #)
                                     }
                                     }; } in
                               case a_s4SV 0 w_s4Yk
                               of _ [Occ=Dead] { (# ipv1_a2PI, ipv2_a2PJ #) ->
                               $w$j1_s4Y6 ipv1_a2PI
                               };
                             True -> $w$j1_s4Y6 w_s4Yk
                           } } in
                     case GHC.Prim.tagToEnum# @ Bool (GHC.Prim.<=# 0 ww_s4Yy)
                     of _ [Occ=Dead] {
                       False -> $j1_s4Mw 0;
                       True ->
                         let {
                           x1_a2HC :: GHC.Prim.Int#
                           [LclId, Str=DmdType]
                           x1_a2HC = GHC.Prim.+# ww_s4Yy 1 } in
                         case GHC.Prim.tagToEnum# @ Bool (GHC.Prim.<# x1_a2HC 0)
                         of _ [Occ=Dead] {
                           False -> $j1_s4Mw x1_a2HC;
                           True -> case error @ Int lvl4_r54D of wild_00 { }
                         }
                     } } in
               case GHC.Prim.tagToEnum# @ Bool (GHC.Prim.<=# 0 ww_s4Yy)
               of _ [Occ=Dead] {
                 False ->
                   case GHC.Prim.newByteArray# @ s_a2xr 0 s1_a2xs
                   of _ [Occ=Dead] { (# ipv1_a2HT, ipv2_a2HU #) ->
                   $w$j_s4Yt ipv1_a2HT lvl2_r54B (GHC.Types.I# ww_s4Yy) 0 ipv2_a2HU
                   };
                 True ->
                   let {
                     n#_X2J4 :: GHC.Prim.Int#
                     [LclId, Str=DmdType]
                     n#_X2J4 = GHC.Prim.+# ww_s4Yy 1 } in
                   case GHC.Prim.newByteArray#
                          @ s_a2xr (GHC.Prim.*# 8 n#_X2J4) s1_a2xs
                   of _ [Occ=Dead] { (# ipv1_a2HT, ipv2_a2HU #) ->
                   $w$j_s4Yt
                     ipv1_a2HT lvl2_r54B (GHC.Types.I# ww_s4Yy) n#_X2J4 ipv2_a2HU
                   }
               } } in
         case GHC.Prim.tagToEnum#
                @ Bool (GHC.Prim.<## x_a2H4 (GHC.Prim.int2Double# n_a2H3))
         of _ [Occ=Dead] {
           False -> $j_s4MD n_a2H3;
           True -> $j_s4MD (GHC.Prim.-# n_a2H3 1)
         })

divisorCounts [InlPrag=INLINE[0]] :: Int -> UArray Int Int
[GblId,
 Arity=1,
 Str=DmdType <S,1*U(U)>,
 Unf=Unf{Src=InlineStable, TopLvl=True, Value=True, ConLike=True,
         WorkFree=True, Expandable=True,
         Guidance=ALWAYS_IF(arity=1,unsat_ok=True,boring_ok=False)
         Tmpl= \ (w_s4Yv [Occ=Once!] :: Int) ->
                 case w_s4Yv of _ [Occ=Dead] { GHC.Types.I# ww1_s4Yy [Occ=Once] ->
                 Main.$wdivisorCounts ww1_s4Yy
                 }}]
divisorCounts =
  \ (w_s4Yv :: Int) ->
    case w_s4Yv of _ [Occ=Dead] { GHC.Types.I# ww1_s4Yy ->
    Main.$wdivisorCounts ww1_s4Yy
    }

Main.main5 :: Int
[GblId,
 Caf=NoCafRefs,
 Str=DmdType,
 Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
         WorkFree=True, Expandable=True, Guidance=IF_ARGS [] 10 20}]
Main.main5 = GHC.Types.I# 342

Main.main2 :: String
[GblId,
 Str=DmdType,
 Unf=Unf{Src=<vanilla>, TopLvl=True, Value=False, ConLike=False,
         WorkFree=False, Expandable=False, Guidance=IF_ARGS [] 770 30}]
Main.main2 =
  case Main.$wdivisorCounts 1000000
  of _ [Occ=Dead]
  { Data.Array.Base.UArray l_a2SB u_a2SC dt_a2SD ds1_a2SE ->
  case l_a2SB of wild1_s52g { GHC.Types.I# m_s52h ->
  case u_a2SC of wild2_s52j { GHC.Types.I# n_s52k ->
  case GHC.Prim.tagToEnum# @ Bool (GHC.Prim.<=# m_s52h 342)
  of _ [Occ=Dead] {
    False ->
      case GHC.Arr.indexError
             @ Int
             @ Int
             GHC.Show.$fShowInt
             (wild1_s52g, wild2_s52j)
             Main.main5
             Main.main4
      of wild5_00 {
      };
    True ->
      case GHC.Prim.tagToEnum# @ Bool (GHC.Prim.<=# 342 n_s52k)
      of _ [Occ=Dead] {
        False ->
          case GHC.Arr.indexError
                 @ Int
                 @ Int
                 GHC.Show.$fShowInt
                 (wild1_s52g, wild2_s52j)
                 Main.main5
                 Main.main4
          of wild6_00 {
          };
        True ->
          let {
            y_a2wI :: GHC.Prim.Int#
            [LclId, Str=DmdType]
            y_a2wI = GHC.Prim.-# 342 m_s52h } in
          let {
            $j_s311 :: GHC.Prim.Void# -> Int
            [LclId, Arity=1, Str=DmdType <B,A>b]
            $j_s311 =
              \ _ [Occ=Dead, OS=OneShot] ->
                error
                  @ Int
                  (GHC.CString.unpackAppendCString#
                     "Error in array index; "#
                     (case GHC.Show.$wshowSignedInt 0 y_a2wI (GHC.Types.[] @ Char)
                      of _ [Occ=Dead] { (# ww5_a2Sl, ww6_a2Sm #) ->
                      ++
                        @ Char
                        (GHC.Types.: @ Char ww5_a2Sl ww6_a2Sm)
                        (GHC.CString.unpackAppendCString#
                           " not in range [0.."#
                           (case GHC.Show.$wshowSignedInt 0 dt_a2SD (GHC.Types.[] @ Char)
                            of _ [Occ=Dead] { (# ww2_X2To, ww3_X2Tq #) ->
                            ++ @ Char (GHC.Types.: @ Char ww2_X2To ww3_X2Tq) Main.main3
                            }))
                      })) } in
          case GHC.Prim.tagToEnum# @ Bool (GHC.Prim.<=# 0 y_a2wI)
          of _ [Occ=Dead] {
            False -> case $j_s311 GHC.Prim.void# of wild7_00 { };
            True ->
              case GHC.Prim.tagToEnum# @ Bool (GHC.Prim.<# y_a2wI dt_a2SD)
              of _ [Occ=Dead] {
                False -> case $j_s311 GHC.Prim.void# of wild8_00 { };
                True ->
                  case GHC.Prim.indexIntArray# ds1_a2SE y_a2wI
                  of wild8_a2TT { __DEFAULT ->
                  case GHC.Show.$wshowSignedInt 0 wild8_a2TT (GHC.Types.[] @ Char)
                  of _ [Occ=Dead] { (# ww5_a2Sl, ww6_a2Sm #) ->
                  GHC.Types.: @ Char ww5_a2Sl ww6_a2Sm
                  }
                  }
              }
          }
      }
  }
  }
  }
  }

Main.main1
  :: GHC.Prim.State# RealWorld -> (# GHC.Prim.State# RealWorld, () #)
[GblId,
 Arity=1,
 Str=DmdType <L,U>,
 Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
         WorkFree=True, Expandable=True, Guidance=IF_ARGS [0] 40 0}]
Main.main1 =
  \ (eta_a31r [OS=OneShot] :: GHC.Prim.State# RealWorld) ->
    GHC.IO.Handle.Text.hPutStr2
      GHC.IO.Handle.FD.stdout Main.main2 GHC.Types.True eta_a31r

main :: IO ()
[GblId,
 Arity=1,
 Str=DmdType <L,U>,
 Unf=Unf{Src=InlineStable, TopLvl=True, Value=True, ConLike=True,
         WorkFree=True, Expandable=True,
         Guidance=ALWAYS_IF(arity=0,unsat_ok=True,boring_ok=True)
         Tmpl= Main.main1
               `cast` (Sym (GHC.Types.NTCo:IO[0] <()>_R)
                       :: (GHC.Prim.State# RealWorld
                           -> (# GHC.Prim.State# RealWorld, () #))
                          ~R# IO ())}]
main =
  Main.main1
  `cast` (Sym (GHC.Types.NTCo:IO[0] <()>_R)
          :: (GHC.Prim.State# RealWorld
              -> (# GHC.Prim.State# RealWorld, () #))
             ~R# IO ())

Main.main6
  :: GHC.Prim.State# RealWorld -> (# GHC.Prim.State# RealWorld, () #)
[GblId,
 Arity=1,
 Str=DmdType,
 Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
         WorkFree=True, Expandable=True, Guidance=IF_ARGS [] 20 60}]
Main.main6 =
  GHC.TopHandler.runMainIO1
    @ ()
    (Main.main1
     `cast` (Sym (GHC.Types.NTCo:IO[0] <()>_R)
             :: (GHC.Prim.State# RealWorld
                 -> (# GHC.Prim.State# RealWorld, () #))
                ~R# IO ()))

:Main.main :: IO ()
[GblId,
 Arity=1,
 Str=DmdType,
 Unf=Unf{Src=InlineStable, TopLvl=True, Value=True, ConLike=True,
         WorkFree=True, Expandable=True,
         Guidance=ALWAYS_IF(arity=0,unsat_ok=True,boring_ok=True)
         Tmpl= Main.main6
               `cast` (Sym (GHC.Types.NTCo:IO[0] <()>_R)
                       :: (GHC.Prim.State# RealWorld
                           -> (# GHC.Prim.State# RealWorld, () #))
                          ~R# IO ())}]
:Main.main =
  Main.main6
  `cast` (Sym (GHC.Types.NTCo:IO[0] <()>_R)
          :: (GHC.Prim.State# RealWorld
              -> (# GHC.Prim.State# RealWorld, () #))
             ~R# IO ())

T5331.good.dump-simpl

==================== Tidy Core ====================
2015-07-07 10:13:26.306479 UTC

Result size of Tidy Core = {terms: 437, types: 392, coercions: 9}

Main.main3 :: [Char]
[GblId,
 Str=DmdType,
 Unf=Unf{Src=<vanilla>, TopLvl=True, Value=False, ConLike=False,
         WorkFree=False, Expandable=False, Guidance=IF_ARGS [] 40 0}]
Main.main3 = GHC.CString.unpackCString# ")"#

Main.main4 :: [Char]
[GblId,
 Str=DmdType,
 Unf=Unf{Src=<vanilla>, TopLvl=True, Value=False, ConLike=False,
         WorkFree=False, Expandable=False, Guidance=IF_ARGS [] 40 0}]
Main.main4 = GHC.CString.unpackCString# "Int"#

isqrt :: Int -> Int
[GblId,
 Arity=1,
 Caf=NoCafRefs,
 Str=DmdType <S,1*U(U)>m,
 Unf=Unf{Src=InlineStable, TopLvl=True, Value=True, ConLike=True,
         WorkFree=True, Expandable=True,
         Guidance=ALWAYS_IF(arity=1,unsat_ok=True,boring_ok=False)
         Tmpl= \ (n_aGY [Occ=Once!] :: Int) ->
                 case n_aGY of _ [Occ=Dead] { GHC.Types.I# i_a2GV [Occ=Once] ->
                 let {
                   x_a2H4 :: GHC.Prim.Double#
                   [LclId, Str=DmdType]
                   x_a2H4 = GHC.Prim.sqrtDouble# (GHC.Prim.int2Double# i_a2GV) } in
                 let {
                   n1_a2H3 :: GHC.Prim.Int#
                   [LclId, Str=DmdType]
                   n1_a2H3 = GHC.Prim.double2Int# x_a2H4 } in
                 case GHC.Prim.tagToEnum#
                        @ Bool (GHC.Prim.<## x_a2H4 (GHC.Prim.int2Double# n1_a2H3))
                 of _ [Occ=Dead] {
                   False -> GHC.Types.I# n1_a2H3;
                   True -> GHC.Types.I# (GHC.Prim.-# n1_a2H3 1)
                 }
                 }}]
isqrt =
  \ (n_aGY :: Int) ->
    case n_aGY of _ [Occ=Dead] { GHC.Types.I# i_a2GV ->
    let {
      x_a2H4 :: GHC.Prim.Double#
      [LclId, Str=DmdType]
      x_a2H4 = GHC.Prim.sqrtDouble# (GHC.Prim.int2Double# i_a2GV) } in
    let {
      n1_a2H3 :: GHC.Prim.Int#
      [LclId, Str=DmdType]
      n1_a2H3 = GHC.Prim.double2Int# x_a2H4 } in
    case GHC.Prim.tagToEnum#
           @ Bool (GHC.Prim.<## x_a2H4 (GHC.Prim.int2Double# n1_a2H3))
    of _ [Occ=Dead] {
      False -> GHC.Types.I# n1_a2H3;
      True -> GHC.Types.I# (GHC.Prim.-# n1_a2H3 1)
    }
    }

lvl2_r56a :: Int
[GblId, Caf=NoCafRefs, Str=DmdType m]
lvl2_r56a = GHC.Types.I# 0

lvl3_r56b :: Int
[GblId, Caf=NoCafRefs, Str=DmdType m]
lvl3_r56b = GHC.Types.I# 2

lvl4_r56c :: [Char]
[GblId, Str=DmdType]
lvl4_r56c = GHC.CString.unpackCString# "Negative range size"#

Main.$wdivisorCounts [InlPrag=[0]]
  :: GHC.Prim.Int# -> UArray Int Int
[GblId, Arity=1, Str=DmdType <L,U>]
Main.$wdivisorCounts =
  \ (ww_s4ZI :: GHC.Prim.Int#) ->
    GHC.ST.runSTRep
      @ (UArray Int Int)
      (\ (@ s_a2xr) (s1_a2xs [OS=OneShot] :: GHC.Prim.State# s_a2xr) ->
         let {
           x_a2H4 :: GHC.Prim.Double#
           [LclId, Str=DmdType]
           x_a2H4 = GHC.Prim.sqrtDouble# (GHC.Prim.int2Double# ww_s4ZI) } in
         let {
           n_a2H3 :: GHC.Prim.Int#
           [LclId, Str=DmdType]
           n_a2H3 = GHC.Prim.double2Int# x_a2H4 } in
         let {
           $j_s4Np
             :: GHC.Prim.Int# -> (# GHC.Prim.State# s_a2xr, UArray Int Int #)
           [LclId, Arity=1, Str=DmdType <L,U>]
           $j_s4Np =
             \ (ipv_s2Hm [OS=OneShot] :: GHC.Prim.Int#) ->
               let {
                 $j1_s2ZK
                   :: GHC.Prim.State# s_a2xr
                      -> STUArray s_a2xr Int Int
                      -> (# GHC.Prim.State# s_a2xr, STUArray s_a2xr Int Int #)
                 [LclId, Arity=2, Str=DmdType <L,U><L,U(U,U,U,U)>]
                 $j1_s2ZK =
                   \ (ipv1_a2Q4 [OS=OneShot] :: GHC.Prim.State# s_a2xr)
                     (ipv2_a2Q5 [OS=OneShot] :: STUArray s_a2xr Int Int) ->
                     let {
                       $j2_s4N3
                         :: GHC.Prim.Int#
                            -> (# GHC.Prim.State# s_a2xr, STUArray s_a2xr Int Int #)
                       [LclId, Arity=1, Str=DmdType <L,U>]
                       $j2_s4N3 =
                         \ (x1_a2Tq [OS=OneShot] :: GHC.Prim.Int#) ->
                           let {
                             y_a2Z3 :: GHC.Prim.Int#
                             [LclId, Str=DmdType]
                             y_a2Z3 = GHC.Prim.-# x1_a2Tq 1 } in
                           case GHC.Prim.tagToEnum# @ Bool (GHC.Prim.># 0 y_a2Z3)
                           of _ [Occ=Dead] {
                             False ->
                               letrec {
                                 a_s4TM [Occ=LoopBreaker]
                                   :: GHC.Prim.Int#
                                      -> GHC.Prim.State# s_a2xr -> (# GHC.Prim.State# s_a2xr, () #)
                                 [LclId, Arity=2, Str=DmdType <L,U><L,U>]
                                 a_s4TM =
                                   \ (x2_a2Z7 :: GHC.Prim.Int#)
                                     (s2_X2RY [OS=OneShot] :: GHC.Prim.State# s_a2xr) ->
                                     case ipv2_a2Q5
                                     of _ [Occ=Dead]
                                     { Data.Array.Base.STUArray ds2_a2Oz ds3_a2OA dt_a2OB
                                                                marr#_a2OC ->
                                     case GHC.Prim.writeIntArray#
                                            @ s_a2xr marr#_a2OC x2_a2Z7 1 s2_X2RY
                                     of s2#_a2OO [OS=OneShot] { __DEFAULT ->
                                     case GHC.Prim.tagToEnum# @ Bool (GHC.Prim.==# x2_a2Z7 y_a2Z3)
                                     of _ [Occ=Dead] {
                                       False -> a_s4TM (GHC.Prim.+# x2_a2Z7 1) s2#_a2OO;
                                       True -> (# s2#_a2OO, GHC.Tuple.() #)
                                     }
                                     }
                                     }; } in
                               case a_s4TM 0 ipv1_a2Q4
                               of _ [Occ=Dead] { (# ipv3_a2PI, ipv4_a2PJ #) ->
                               (# ipv3_a2PI, ipv2_a2Q5 #)
                               };
                             True -> (# ipv1_a2Q4, ipv2_a2Q5 #)
                           } } in
                     case GHC.Prim.tagToEnum# @ Bool (GHC.Prim.<=# 0 ww_s4ZI)
                     of _ [Occ=Dead] {
                       False -> $j2_s4N3 0;
                       True ->
                         let {
                           x1_a2HC :: GHC.Prim.Int#
                           [LclId, Str=DmdType]
                           x1_a2HC = GHC.Prim.+# ww_s4ZI 1 } in
                         case GHC.Prim.tagToEnum# @ Bool (GHC.Prim.<# x1_a2HC 0)
                         of _ [Occ=Dead] {
                           False -> $j2_s4N3 x1_a2HC;
                           True -> case error @ Int lvl4_r56c of wild_00 { }
                         }
                     } } in
               let {
                 $w$j_s4Zo [InlPrag=[0]]
                   :: GHC.Prim.State# s_a2xr
                      -> Int
                      -> Int
                      -> GHC.Prim.Int#
                      -> GHC.Prim.MutableByteArray# s_a2xr
                      -> (# GHC.Prim.State# s_a2xr, UArray Int Int #)
                 [LclId, Arity=5, Str=DmdType <L,U><S,U><S,U><L,U><L,U>]
                 $w$j_s4Zo =
                   \ (w_s4Zf [OS=OneShot] :: GHC.Prim.State# s_a2xr)
                     (ww1_s4Zj [OS=OneShot] :: Int)
                     (ww2_s4Zk [OS=OneShot] :: Int)
                     (ww3_s4Zl [OS=OneShot] :: GHC.Prim.Int#)
                     (ww4_s4Zm [OS=OneShot] :: GHC.Prim.MutableByteArray# s_a2xr) ->
                     letrec {
                       $wa_s4Z7 [InlPrag=[0], Occ=LoopBreaker]
                         :: Int
                            -> GHC.Prim.Int#
                            -> GHC.Prim.State# s_a2xr
                            -> (# GHC.Prim.State# s_a2xr, () #)
                       [LclId, Arity=3, Str=DmdType <L,U(U)><L,U><L,U>]
                       $wa_s4Z7 =
                         \ (w1_s4Z0 :: Int)
                           (ww5_s4Z5 :: GHC.Prim.Int#)
                           (w2_s4Z2 [OS=OneShot] :: GHC.Prim.State# s_a2xr) ->
                           case GHC.Prim.tagToEnum# @ Bool (GHC.Prim.># ww5_s4Z5 ww_s4ZI)
                           of _ [Occ=Dead] {
                             False ->
                               case GHC.Prim.readIntArray# @ s_a2xr ww4_s4Zm ww5_s4Z5 w2_s4Z2
                               of _ [Occ=Dead] { (# ipv1_a30b, ipv2_a30c #) ->
                               case GHC.Prim.writeIntArray#
                                      @ s_a2xr ww4_s4Zm ww5_s4Z5 (GHC.Prim.+# ipv2_a30c 1) ipv1_a30b
                               of s2#_a30G [OS=OneShot] { __DEFAULT ->
                               case w1_s4Z0 of wild1_a2Pk { GHC.Types.I# y_a2Pm ->
                               $wa_s4Z7 wild1_a2Pk (GHC.Prim.+# ww5_s4Z5 y_a2Pm) s2#_a30G
                               }
                               }
                               };
                             True -> (# w2_s4Z2, GHC.Tuple.() #)
                           }; } in
                     case $wa_s4Z7 lvl3_r56b 4 w_s4Zf
                     of _ [Occ=Dead] { (# ipv1_a2PI, ipv2_a2PJ #) ->
                     letrec {
                       $wa1_s4Ze [InlPrag=[0], Occ=LoopBreaker]
                         :: GHC.Prim.Int#
                            -> GHC.Prim.State# s_a2xr -> (# GHC.Prim.State# s_a2xr, () #)
                       [LclId, Arity=2, Str=DmdType <L,U><L,U>]
                       $wa1_s4Ze =
                         \ (ww5_s4Zc :: GHC.Prim.Int#)
                           (w1_s4Z9 [OS=OneShot] :: GHC.Prim.State# s_a2xr) ->
                           case GHC.Prim.tagToEnum# @ Bool (GHC.Prim.># ww5_s4Zc ipv_s2Hm)
                           of _ [Occ=Dead] {
                             False ->
                               case $wa_s4Z7
                                      (GHC.Types.I# (GHC.Prim.*# 2 ww5_s4Zc))
                                      (GHC.Prim.*# ww5_s4Zc ww5_s4Zc)
                                      w1_s4Z9
                               of _ [Occ=Dead] { (# ipv3_X2Rb, ipv4_X2Rd #) ->
                               $wa1_s4Ze (GHC.Prim.+# ww5_s4Zc 2) ipv3_X2Rb
                               };
                             True -> (# w1_s4Z9, GHC.Tuple.() #)
                           }; } in
                     case $wa1_s4Ze 3 ipv1_a2PI
                     of _ [Occ=Dead] { (# ipv3_X2R4, ipv4_X2R6 #) ->
                     case GHC.Prim.unsafeFreezeByteArray# @ s_a2xr ww4_s4Zm ipv3_X2R4
                     of _ [Occ=Dead] { (# ipv5_a2xM, ipv6_a2xN #) ->
                     (# ipv5_a2xM,
                        Data.Array.Base.UArray
                          @ Int @ Int ww1_s4Zj ww2_s4Zk ww3_s4Zl ipv6_a2xN #)
                     }
                     }
                     } } in
               case GHC.Prim.tagToEnum# @ Bool (GHC.Prim.<=# 0 ww_s4ZI)
               of _ [Occ=Dead] {
                 False ->
                   case GHC.Prim.newByteArray# @ s_a2xr 0 s1_a2xs
                   of _ [Occ=Dead] { (# ipv1_a2HT, ipv2_a2HU #) ->
                   case $j1_s2ZK
                          ipv1_a2HT
                          (Data.Array.Base.STUArray
                             @ s_a2xr @ Int @ Int lvl2_r56a (GHC.Types.I# ww_s4ZI) 0 ipv2_a2HU)
                   of _ [Occ=Dead] { (# ipv3_X2QV, ipv4_X2Rs #) ->
                   case ipv4_X2Rs
                   of _ [Occ=Dead]
                   { Data.Array.Base.STUArray ww2_s4Zj ww3_s4Zk ww4_s4Zl ww5_s4Zm ->
                   $w$j_s4Zo ipv3_X2QV ww2_s4Zj ww3_s4Zk ww4_s4Zl ww5_s4Zm
                   }
                   }
                   };
                 True ->
                   let {
                     n#_X2J5 :: GHC.Prim.Int#
                     [LclId, Str=DmdType]
                     n#_X2J5 = GHC.Prim.+# ww_s4ZI 1 } in
                   case GHC.Prim.newByteArray#
                          @ s_a2xr (GHC.Prim.*# 8 n#_X2J5) s1_a2xs
                   of _ [Occ=Dead] { (# ipv1_a2HT, ipv2_a2HU #) ->
                   case $j1_s2ZK
                          ipv1_a2HT
                          (Data.Array.Base.STUArray
                             @ s_a2xr
                             @ Int
                             @ Int
                             lvl2_r56a
                             (GHC.Types.I# ww_s4ZI)
                             n#_X2J5
                             ipv2_a2HU)
                   of _ [Occ=Dead] { (# ipv3_X2QX, ipv4_X2Ru #) ->
                   case ipv4_X2Ru
                   of _ [Occ=Dead]
                   { Data.Array.Base.STUArray ww2_s4Zj ww3_s4Zk ww4_s4Zl ww5_s4Zm ->
                   $w$j_s4Zo ipv3_X2QX ww2_s4Zj ww3_s4Zk ww4_s4Zl ww5_s4Zm
                   }
                   }
                   }
               } } in
         case GHC.Prim.tagToEnum#
                @ Bool (GHC.Prim.<## x_a2H4 (GHC.Prim.int2Double# n_a2H3))
         of _ [Occ=Dead] {
           False -> $j_s4Np n_a2H3;
           True -> $j_s4Np (GHC.Prim.-# n_a2H3 1)
         })

divisorCounts [InlPrag=INLINE[0]] :: Int -> UArray Int Int
[GblId,
 Arity=1,
 Str=DmdType <S,1*U(U)>,
 Unf=Unf{Src=InlineStable, TopLvl=True, Value=True, ConLike=True,
         WorkFree=True, Expandable=True,
         Guidance=ALWAYS_IF(arity=1,unsat_ok=True,boring_ok=False)
         Tmpl= \ (w_s4ZF [Occ=Once!] :: Int) ->
                 case w_s4ZF of _ [Occ=Dead] { GHC.Types.I# ww1_s4ZI [Occ=Once] ->
                 Main.$wdivisorCounts ww1_s4ZI
                 }}]
divisorCounts =
  \ (w_s4ZF :: Int) ->
    case w_s4ZF of _ [Occ=Dead] { GHC.Types.I# ww1_s4ZI ->
    Main.$wdivisorCounts ww1_s4ZI
    }

Main.main5 :: Int
[GblId,
 Caf=NoCafRefs,
 Str=DmdType,
 Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
         WorkFree=True, Expandable=True, Guidance=IF_ARGS [] 10 20}]
Main.main5 = GHC.Types.I# 342

Main.main2 :: String
[GblId,
 Str=DmdType,
 Unf=Unf{Src=<vanilla>, TopLvl=True, Value=False, ConLike=False,
         WorkFree=False, Expandable=False, Guidance=IF_ARGS [] 770 30}]
Main.main2 =
  case Main.$wdivisorCounts 1000000
  of _ [Occ=Dead]
  { Data.Array.Base.UArray l_a2SB u_a2SC dt_a2SD ds1_a2SE ->
  case l_a2SB of wild1_s53G { GHC.Types.I# m_s53H ->
  case u_a2SC of wild2_s53J { GHC.Types.I# n_s53K ->
  case GHC.Prim.tagToEnum# @ Bool (GHC.Prim.<=# m_s53H 342)
  of _ [Occ=Dead] {
    False ->
      case GHC.Arr.indexError
             @ Int
             @ Int
             GHC.Show.$fShowInt
             (wild1_s53G, wild2_s53J)
             Main.main5
             Main.main4
      of wild5_00 {
      };
    True ->
      case GHC.Prim.tagToEnum# @ Bool (GHC.Prim.<=# 342 n_s53K)
      of _ [Occ=Dead] {
        False ->
          case GHC.Arr.indexError
                 @ Int
                 @ Int
                 GHC.Show.$fShowInt
                 (wild1_s53G, wild2_s53J)
                 Main.main5
                 Main.main4
          of wild6_00 {
          };
        True ->
          let {
            y_a2wI :: GHC.Prim.Int#
            [LclId, Str=DmdType]
            y_a2wI = GHC.Prim.-# 342 m_s53H } in
          let {
            $j_s31J :: GHC.Prim.Void# -> Int
            [LclId, Arity=1, Str=DmdType <B,A>b]
            $j_s31J =
              \ _ [Occ=Dead, OS=OneShot] ->
                error
                  @ Int
                  (GHC.CString.unpackAppendCString#
                     "Error in array index; "#
                     (case GHC.Show.$wshowSignedInt 0 y_a2wI (GHC.Types.[] @ Char)
                      of _ [Occ=Dead] { (# ww5_a2Sl, ww6_a2Sm #) ->
                      ++
                        @ Char
                        (GHC.Types.: @ Char ww5_a2Sl ww6_a2Sm)
                        (GHC.CString.unpackAppendCString#
                           " not in range [0.."#
                           (case GHC.Show.$wshowSignedInt 0 dt_a2SD (GHC.Types.[] @ Char)
                            of _ [Occ=Dead] { (# ww2_X2Ti, ww3_X2Tk #) ->
                            ++ @ Char (GHC.Types.: @ Char ww2_X2Ti ww3_X2Tk) Main.main3
                            }))
                      })) } in
          case GHC.Prim.tagToEnum# @ Bool (GHC.Prim.<=# 0 y_a2wI)
          of _ [Occ=Dead] {
            False -> case $j_s31J GHC.Prim.void# of wild7_00 { };
            True ->
              case GHC.Prim.tagToEnum# @ Bool (GHC.Prim.<# y_a2wI dt_a2SD)
              of _ [Occ=Dead] {
                False -> case $j_s31J GHC.Prim.void# of wild8_00 { };
                True ->
                  case GHC.Prim.indexIntArray# ds1_a2SE y_a2wI
                  of wild8_a2TT { __DEFAULT ->
                  case GHC.Show.$wshowSignedInt 0 wild8_a2TT (GHC.Types.[] @ Char)
                  of _ [Occ=Dead] { (# ww5_a2Sl, ww6_a2Sm #) ->
                  GHC.Types.: @ Char ww5_a2Sl ww6_a2Sm
                  }
                  }
              }
          }
      }
  }
  }
  }
  }

Main.main1
  :: GHC.Prim.State# RealWorld -> (# GHC.Prim.State# RealWorld, () #)
[GblId,
 Arity=1,
 Str=DmdType <L,U>,
 Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
         WorkFree=True, Expandable=True, Guidance=IF_ARGS [0] 40 0}]
Main.main1 =
  \ (eta_a329 [OS=OneShot] :: GHC.Prim.State# RealWorld) ->
    GHC.IO.Handle.Text.hPutStr2
      GHC.IO.Handle.FD.stdout Main.main2 GHC.Types.True eta_a329

main :: IO ()
[GblId,
 Arity=1,
 Str=DmdType <L,U>,
 Unf=Unf{Src=InlineStable, TopLvl=True, Value=True, ConLike=True,
         WorkFree=True, Expandable=True,
         Guidance=ALWAYS_IF(arity=0,unsat_ok=True,boring_ok=True)
         Tmpl= Main.main1
               `cast` (Sym (GHC.Types.NTCo:IO[0] <()>_R)
                       :: (GHC.Prim.State# RealWorld
                           -> (# GHC.Prim.State# RealWorld, () #))
                          ~R# IO ())}]
main =
  Main.main1
  `cast` (Sym (GHC.Types.NTCo:IO[0] <()>_R)
          :: (GHC.Prim.State# RealWorld
              -> (# GHC.Prim.State# RealWorld, () #))
             ~R# IO ())

Main.main6
  :: GHC.Prim.State# RealWorld -> (# GHC.Prim.State# RealWorld, () #)
[GblId,
 Arity=1,
 Str=DmdType,
 Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
         WorkFree=True, Expandable=True, Guidance=IF_ARGS [] 20 60}]
Main.main6 =
  GHC.TopHandler.runMainIO1
    @ ()
    (Main.main1
     `cast` (Sym (GHC.Types.NTCo:IO[0] <()>_R)
             :: (GHC.Prim.State# RealWorld
                 -> (# GHC.Prim.State# RealWorld, () #))
                ~R# IO ()))

:Main.main :: IO ()
[GblId,
 Arity=1,
 Str=DmdType,
 Unf=Unf{Src=InlineStable, TopLvl=True, Value=True, ConLike=True,
         WorkFree=True, Expandable=True,
         Guidance=ALWAYS_IF(arity=0,unsat_ok=True,boring_ok=True)
         Tmpl= Main.main6
               `cast` (Sym (GHC.Types.NTCo:IO[0] <()>_R)
                       :: (GHC.Prim.State# RealWorld
                           -> (# GHC.Prim.State# RealWorld, () #))
                          ~R# IO ())}]
:Main.main =
  Main.main6
  `cast` (Sym (GHC.Types.NTCo:IO[0] <()>_R)
          :: (GHC.Prim.State# RealWorld
              -> (# GHC.Prim.State# RealWorld, () #))
             ~R# IO ())