GHC Core

Simplify


Main.my_foldr_r71 :: ∀t_a7l. ∀t_a7q. (t_a7q → t_a7l → t_a7l) → t_a7l → [t_a7q] → t_a7l
[Exported]
Arity 3
Main.my_foldr_r71
= Λ(t_a7l :: GHC.Prim.*) →
   Λ(t_a7q :: GHC.Prim.*) →
    λ(c_a77 :: t_a7q → t_a7l → t_a7l) →
     λ(n_a79 :: t_a7l) →
      λ(eta_srZ :: [t_a7q]) →
           letrec
                 my_foldr'_a7b LoopBreaker :: [t_a7q] → t_a7l
                 Arity 1
                 my_foldr'_a7b LoopBreaker
                 = λ(ds_drR :: [t_a7q]) →
                    case ds_drR@(wild_B1 :: [t_a7q]) of
                        [GHC.Base.[]] → n_a79
                        [GHC.Base.: x_a7d xs_a7f] → c_a77 x_a7d (my_foldr'_a7b xs_a7f)
       in my_foldr'_a7b eta_srZ

Main.my_id_r6X :: ∀t_alK. t_alK → t_alK
[Exported]
Arity 1
Main.my_id_r6X = Λ(t_alK :: GHC.Prim.*) → λ(x_a75 :: t_alK) → x_a75

Main.foo_r8 :: GHC.Integer.Integer
[Exported]
Main.foo_r8 = GHC.Integer.plusInteger (GHC.Integer.smallInteger 1) (GHC.Integer.smallInteger 1)

Main.bar_r73 :: GHC.Bool.Bool
[Exported]
Main.bar_r73
= case (GHC.Base.> GHC.Integer.Integer GHC.Num.$f4 Main.foo_r8 (GHC.Integer.smallInteger 2))@(wild_B1 Dead :: GHC.Bool.Bool) of
      [GHC.Bool.False] → GHC.Bool.True
      [GHC.Bool.True] → GHC.Bool.False

$dShow_akn :: GHC.Show.Show [GHC.Base.Char]
$dShow_akn = GHC.Show.$f21 GHC.Base.Char GHC.Show.$f18

a_ssk :: [GHC.Base.Char]
a_ssk = GHC.Base.unpackCString# "Hello World"

Main.main_r72 :: GHC.IOBase.IO ()
[Exported]
Arity 1
Main.main_r72 = System.IO.print [GHC.Base.Char] $dShow_akn a_ssk

:Main.main :: GHC.IOBase.IO ()
[Exported]
Arity 1
:Main.main = GHC.TopHandler.runMainIO () Main.main_r72

Static Argument Transformation


Main.my_foldr_r71 :: ∀t_a7l. ∀t_a7q. (t_a7q → t_a7l → t_a7l) → t_a7l → [t_a7q] → t_a7l
[Exported]
Arity 3
Main.my_foldr_r71
= Λ(t_a7l :: GHC.Prim.*) →
   Λ(t_a7q :: GHC.Prim.*) →
    λ(c_a77 :: t_a7q → t_a7l → t_a7l) →
     λ(n_a79 :: t_a7l) →
      λ(eta_srZ :: [t_a7q]) →
           letrec
                 my_foldr'_a7b LoopBreaker :: [t_a7q] → t_a7l
                 Arity 1
                 my_foldr'_a7b LoopBreaker
                 = λ(ds_drR :: [t_a7q]) →
                    case ds_drR@(wild_B1 :: [t_a7q]) of
                        [GHC.Base.[]] → n_a79
                        [GHC.Base.: x_a7d xs_a7f] → c_a77 x_a7d (my_foldr'_a7b xs_a7f)
       in my_foldr'_a7b eta_srZ

Main.my_id_r6X :: ∀t_alK. t_alK → t_alK
[Exported]
Arity 1
Main.my_id_r6X = Λ(t_alK :: GHC.Prim.*) → λ(x_a75 :: t_alK) → x_a75

Main.foo_r8 :: GHC.Integer.Integer
[Exported]
Main.foo_r8 = GHC.Integer.plusInteger (GHC.Integer.smallInteger 1) (GHC.Integer.smallInteger 1)

Main.bar_r73 :: GHC.Bool.Bool
[Exported]
Main.bar_r73
= case (GHC.Base.> GHC.Integer.Integer GHC.Num.$f4 Main.foo_r8 (GHC.Integer.smallInteger 2))@(wild_B1 Dead :: GHC.Bool.Bool) of
      [GHC.Bool.False] → GHC.Bool.True
      [GHC.Bool.True] → GHC.Bool.False

$dShow_akn :: GHC.Show.Show [GHC.Base.Char]
$dShow_akn = GHC.Show.$f21 GHC.Base.Char GHC.Show.$f18

a_ssk :: [GHC.Base.Char]
a_ssk = GHC.Base.unpackCString# "Hello World"

Main.main_r72 :: GHC.IOBase.IO ()
[Exported]
Arity 1
Main.main_r72 = System.IO.print [GHC.Base.Char] $dShow_akn a_ssk

:Main.main :: GHC.IOBase.IO ()
[Exported]
Arity 1
:Main.main = GHC.TopHandler.runMainIO () Main.main_r72

Simplify


Main.my_foldr_r71 :: ∀t_a7l. ∀t_a7q. (t_a7q → t_a7l → t_a7l) → t_a7l → [t_a7q] → t_a7l
[Exported]
Arity 3
Main.my_foldr_r71
= Λ(t_a7l :: GHC.Prim.*) →
   Λ(t_a7q :: GHC.Prim.*) →
    λ(c_a77 :: t_a7q → t_a7l → t_a7l) →
     λ(n_a79 :: t_a7l) →
      λ(eta_srZ :: [t_a7q]) →
           letrec
                 my_foldr'_a7b LoopBreaker :: [t_a7q] → t_a7l
                 Arity 1
                 my_foldr'_a7b LoopBreaker
                 = λ(ds_drR :: [t_a7q]) →
                    case ds_drR@(wild_B1 :: [t_a7q]) of
                        [GHC.Base.[]] → n_a79
                        [GHC.Base.: x_a7d xs_a7f] → c_a77 x_a7d (my_foldr'_a7b xs_a7f)
       in my_foldr'_a7b eta_srZ

Main.my_id_r6X :: ∀t_alK. t_alK → t_alK
[Exported]
Arity 1
Main.my_id_r6X = Λ(t_alK :: GHC.Prim.*) → λ(x_a75 :: t_alK) → x_a75

Main.foo_r8 :: GHC.Integer.Integer
[Exported]
Main.foo_r8 = GHC.Integer.plusInteger (GHC.Integer.smallInteger 1) (GHC.Integer.smallInteger 1)

Main.bar_r73 :: GHC.Bool.Bool
[Exported]
Main.bar_r73
= case (GHC.Base.> GHC.Integer.Integer GHC.Num.$f4 Main.foo_r8 (GHC.Integer.smallInteger 2))@(wild_B1 Dead :: GHC.Bool.Bool) of
      [GHC.Bool.False] → GHC.Bool.True
      [GHC.Bool.True] → GHC.Bool.False

$dShow_akn :: GHC.Show.Show [GHC.Base.Char]
$dShow_akn = GHC.Show.$f21 GHC.Base.Char GHC.Show.$f18

a_ssk :: [GHC.Base.Char]
a_ssk = GHC.Base.unpackCString# "Hello World"

Main.main_r72 :: GHC.IOBase.IO ()
[Exported]
Arity 1
Main.main_r72 = System.IO.print [GHC.Base.Char] $dShow_akn a_ssk

:Main.main :: GHC.IOBase.IO ()
[Exported]
Arity 1
:Main.main = GHC.TopHandler.runMainIO () Main.main_r72

Specialisation


$dShow_akn :: GHC.Show.Show [GHC.Base.Char]
$dShow_akn = GHC.Show.$f21 GHC.Base.Char GHC.Show.$f18

Main.my_foldr_r71 :: ∀t_a7l. ∀t_a7q. (t_a7q → t_a7l → t_a7l) → t_a7l → [t_a7q] → t_a7l
[Exported]
Arity 3
Main.my_foldr_r71
= Λ(t_a7l :: GHC.Prim.*) →
   Λ(t_a7q :: GHC.Prim.*) →
    λ(c_a77 :: t_a7q → t_a7l → t_a7l) →
     λ(n_a79 :: t_a7l) →
      λ(eta_srZ :: [t_a7q]) →
           letrec
                 my_foldr'_ssA LoopBreaker :: [t_a7q] → t_a7l
                 Arity 1
                 my_foldr'_ssA LoopBreaker
                 = λ(ds_drR :: [t_a7q]) →
                    case ds_drR@(wild_B1 :: [t_a7q]) of
                        [GHC.Base.[]] → n_a79
                        [GHC.Base.: x_a7d xs_a7f] → c_a77 x_a7d (my_foldr'_ssA xs_a7f)
       in my_foldr'_ssA eta_srZ

Main.my_id_r6X :: ∀t_alK. t_alK → t_alK
[Exported]
Arity 1
Main.my_id_r6X = Λ(t_alK :: GHC.Prim.*) → λ(x_a75 :: t_alK) → x_a75

Main.foo_r8 :: GHC.Integer.Integer
[Exported]
Main.foo_r8 = GHC.Integer.plusInteger (GHC.Integer.smallInteger 1) (GHC.Integer.smallInteger 1)

Main.bar_r73 :: GHC.Bool.Bool
[Exported]
Main.bar_r73
= case (GHC.Base.> GHC.Integer.Integer GHC.Num.$f4 Main.foo_r8 (GHC.Integer.smallInteger 2))@(wild_B1 Dead :: GHC.Bool.Bool) of
      [GHC.Bool.False] → GHC.Bool.True
      [GHC.Bool.True] → GHC.Bool.False

a_ssk :: [GHC.Base.Char]
a_ssk = GHC.Base.unpackCString# "Hello World"

Main.main_r72 :: GHC.IOBase.IO ()
[Exported]
Arity 1
Main.main_r72 = System.IO.print [GHC.Base.Char] $dShow_akn a_ssk

:Main.main :: GHC.IOBase.IO ()
[Exported]
Arity 1
:Main.main = GHC.TopHandler.runMainIO () Main.main_r72

Float Outwards


$dShow_akn :: GHC.Show.Show [GHC.Base.Char]
$dShow_akn = GHC.Show.$f21 GHC.Base.Char GHC.Show.$f18

Main.my_foldr_r71 :: ∀t_a7l. ∀t_a7q. (t_a7q → t_a7l → t_a7l) → t_a7l → [t_a7q] → t_a7l
[Exported]
Arity 3
Main.my_foldr_r71
= Λ(t_a7l :: GHC.Prim.*) →
   Λ(t_a7q :: GHC.Prim.*) →
    λ(c_a77 :: t_a7q → t_a7l → t_a7l) →
     λ(n_a79 :: t_a7l) →
      λ(eta_srZ :: [t_a7q]) →
           letrec
                 my_foldr'_ssD LoopBreaker :: [t_a7q] → t_a7l
                 Arity 1
                 my_foldr'_ssD LoopBreaker
                 = λ(ds_drR :: [t_a7q]) →
                    case ds_drR@(wild_B1 :: [t_a7q]) of
                        [GHC.Base.[]] → n_a79
                        [GHC.Base.: x_a7d xs_a7f] → c_a77 x_a7d (my_foldr'_ssD xs_a7f)
       in my_foldr'_ssD eta_srZ

Main.my_id_r6X :: ∀t_alK. t_alK → t_alK
[Exported]
Arity 1
Main.my_id_r6X = Λ(t_alK :: GHC.Prim.*) → λ(x_a75 :: t_alK) → x_a75

Main.foo_r8 :: GHC.Integer.Integer
[Exported]
Main.foo_r8 = GHC.Integer.plusInteger (GHC.Integer.smallInteger 1) (GHC.Integer.smallInteger 1)

Main.bar_r73 :: GHC.Bool.Bool
[Exported]
Main.bar_r73
= case (GHC.Base.> GHC.Integer.Integer GHC.Num.$f4 Main.foo_r8 (GHC.Integer.smallInteger 2))@(wild_B1 Dead :: GHC.Bool.Bool) of
      [GHC.Bool.False] → GHC.Bool.True
      [GHC.Bool.True] → GHC.Bool.False

a_ssk :: [GHC.Base.Char]
a_ssk = GHC.Base.unpackCString# "Hello World"

Main.main_r72 :: GHC.IOBase.IO ()
[Exported]
Arity 1
Main.main_r72 = System.IO.print [GHC.Base.Char] $dShow_akn a_ssk

:Main.main :: GHC.IOBase.IO ()
[Exported]
Arity 1
:Main.main = GHC.TopHandler.runMainIO () Main.main_r72

Float Inwards


$dShow_akn :: GHC.Show.Show [GHC.Base.Char]
$dShow_akn = GHC.Show.$f21 GHC.Base.Char GHC.Show.$f18

Main.my_foldr_r71 :: ∀t_a7l. ∀t_a7q. (t_a7q → t_a7l → t_a7l) → t_a7l → [t_a7q] → t_a7l
[Exported]
Arity 3
Main.my_foldr_r71
= Λ(t_a7l :: GHC.Prim.*) →
   Λ(t_a7q :: GHC.Prim.*) →
    λ(c_a77 :: t_a7q → t_a7l → t_a7l) →
     λ(n_a79 :: t_a7l) →
      λ(eta_srZ :: [t_a7q]) →
           letrec
                 my_foldr'_ssD LoopBreaker :: [t_a7q] → t_a7l
                 Arity 1
                 my_foldr'_ssD LoopBreaker
                 = λ(ds_drR :: [t_a7q]) →
                    case ds_drR@(wild_B1 :: [t_a7q]) of
                        [GHC.Base.[]] → n_a79
                        [GHC.Base.: x_a7d xs_a7f] → c_a77 x_a7d (my_foldr'_ssD xs_a7f)
       in my_foldr'_ssD
       eta_srZ

Main.my_id_r6X :: ∀t_alK. t_alK → t_alK
[Exported]
Arity 1
Main.my_id_r6X = Λ(t_alK :: GHC.Prim.*) → λ(x_a75 :: t_alK) → x_a75

Main.foo_r8 :: GHC.Integer.Integer
[Exported]
Main.foo_r8 = GHC.Integer.plusInteger (GHC.Integer.smallInteger 1) (GHC.Integer.smallInteger 1)

Main.bar_r73 :: GHC.Bool.Bool
[Exported]
Main.bar_r73
= case (GHC.Base.> GHC.Integer.Integer GHC.Num.$f4 Main.foo_r8 (GHC.Integer.smallInteger 2))@(wild_B1 Dead :: GHC.Bool.Bool) of
      [GHC.Bool.False] → GHC.Bool.True
      [GHC.Bool.True] → GHC.Bool.False

a_ssk :: [GHC.Base.Char]
a_ssk = GHC.Base.unpackCString# "Hello World"

Main.main_r72 :: GHC.IOBase.IO ()
[Exported]
Arity 1
Main.main_r72 = System.IO.print [GHC.Base.Char] $dShow_akn a_ssk

:Main.main :: GHC.IOBase.IO ()
[Exported]
Arity 1
:Main.main = GHC.TopHandler.runMainIO () Main.main_r72

Simplify


Main.my_foldr_r71 :: ∀t_a7l. ∀t_a7q. (t_a7q → t_a7l → t_a7l) → t_a7l → [t_a7q] → t_a7l
[Exported]
Arity 3
Main.my_foldr_r71
= Λ(t_a7l :: GHC.Prim.*) →
   Λ(t_a7q :: GHC.Prim.*) →
    λ(c_a77 :: t_a7q → t_a7l → t_a7l) →
     λ(n_a79 :: t_a7l) →
      λ(eta_srZ :: [t_a7q]) →
           letrec
                 my_foldr'_ssD LoopBreaker :: [t_a7q] → t_a7l
                 Arity 1
                 my_foldr'_ssD LoopBreaker
                 = λ(ds_drR :: [t_a7q]) →
                    case ds_drR@(wild_B1 :: [t_a7q]) of
                        [GHC.Base.[]] → n_a79
                        [GHC.Base.: x_a7d xs_a7f] → c_a77 x_a7d (my_foldr'_ssD xs_a7f)
       in my_foldr'_ssD eta_srZ

Main.my_id_r6X :: ∀t_alK. t_alK → t_alK
[Exported]
Arity 1
Main.my_id_r6X = Λ(t_alK :: GHC.Prim.*) → λ(x_a75 :: t_alK) → x_a75

Main.foo_r8 :: GHC.Integer.Integer
[Exported]
Main.foo_r8 = GHC.Integer.plusInteger (GHC.Integer.S# 1) (GHC.Integer.S# 1)

Main.bar_r73 :: GHC.Bool.Bool
[Exported]
Main.bar_r73
= case Main.foo_r8@(wild_atA :: GHC.Integer.Integer) of
      [GHC.Integer.S# i_atC]
      →
      case (GHC.Prim.># i_atC 2)@(wild_Xw Dead :: GHC.Bool.Bool) of
          [GHC.Bool.False] → GHC.Bool.True
          [GHC.Bool.True] → GHC.Bool.False
      [GHC.Integer.J# s_atO d_atP]
      →
      case (GHC.Prim.cmpIntegerInt# s_atO d_atP 2)@(wild2_atV :: GHC.Prim.Int#) of
          _
          →
          case (GHC.Prim.># wild2_atV 0)@(wild_Xw Dead :: GHC.Bool.Bool) of
              [GHC.Bool.False] → GHC.Bool.True
              [GHC.Bool.True] → GHC.Bool.False

a_sAA :: (GHC.Prim.State# GHC.Prim.RealWorld) → (#GHC.Prim.State# GHC.Prim.RealWorld, ()#)
Arity 1
a_sAA
= λ(eta1_aum :: GHC.Prim.State# GHC.Prim.RealWorld) →
   case
   (GHC.IO.a25
    GHC.Handle.stdout
    (GHC.Base.: GHC.Base.Char GHC.Show.a77 (GHC.Show.showl (GHC.Base.build GHC.Base.Char (Λ(b_au5 :: GHC.Prim.*) → GHC.Base.unpackFoldrCString# b_au5 "Hello World")) (GHC.Base.[] GHC.Base.Char)))
    eta1_aum)@(wild_aAn Dead :: (#GHC.Prim.State# GHC.Prim.RealWorld, ()#))
   of  (#new_s_aAp, a59_aAq Dead#) → GHC.IO.$wa13 GHC.Handle.stdout '
' new_s_aAp

Main.main_r72 :: GHC.IOBase.IO ()
[Exported]
Arity 1
Main.main_r72 = a_sAA ▶ (GHC.Prim.sym (GHC.IOBase.:CoIO ()))

a_sAC :: (GHC.Prim.State# GHC.Prim.RealWorld) → (#GHC.Prim.State# GHC.Prim.RealWorld, ()#)
Arity 1
a_sAC = GHC.TopHandler.a6 () (a_sAA ▶ (GHC.Prim.sym (GHC.IOBase.:CoIO ())))

:Main.main :: GHC.IOBase.IO ()
[Exported]
Arity 1
:Main.main = a_sAC ▶ (GHC.Prim.sym (GHC.IOBase.:CoIO ()))

Simplify


Main.my_foldr_r71 :: ∀t_a7l. ∀t_a7q. (t_a7q → t_a7l → t_a7l) → t_a7l → [t_a7q] → t_a7l
[Exported]
Arity 3
Main.my_foldr_r71
= Λ(t_a7l :: GHC.Prim.*) →
   Λ(t_a7q :: GHC.Prim.*) →
    λ(c_a77 :: t_a7q → t_a7l → t_a7l) →
     λ(n_a79 :: t_a7l) →
      λ(eta_srZ :: [t_a7q]) →
           letrec
                 my_foldr'_ssD LoopBreaker :: [t_a7q] → t_a7l
                 Arity 1
                 my_foldr'_ssD LoopBreaker
                 = λ(ds_drR :: [t_a7q]) →
                    case ds_drR@(wild_B1 :: [t_a7q]) of
                        [GHC.Base.[]] → n_a79
                        [GHC.Base.: x_a7d xs_a7f] → c_a77 x_a7d (my_foldr'_ssD xs_a7f)
       in my_foldr'_ssD eta_srZ

Main.my_id_r6X :: ∀t_alK. t_alK → t_alK
[Exported]
Arity 1
Main.my_id_r6X = Λ(t_alK :: GHC.Prim.*) → λ(x_a75 :: t_alK) → x_a75

Main.foo_r8 :: GHC.Integer.Integer
[Exported]
Main.foo_r8 = GHC.Integer.plusInteger (GHC.Integer.S# 1) (GHC.Integer.S# 1)

Main.bar_r73 :: GHC.Bool.Bool
[Exported]
Main.bar_r73
= case Main.foo_r8@(wild_atA :: GHC.Integer.Integer) of
      [GHC.Integer.S# i_atC]
      →
      case (GHC.Prim.># i_atC 2)@(wild_Xw Dead :: GHC.Bool.Bool) of
          [GHC.Bool.False] → GHC.Bool.True
          [GHC.Bool.True] → GHC.Bool.False
      [GHC.Integer.J# s_atO d_atP]
      →
      case (GHC.Prim.cmpIntegerInt# s_atO d_atP 2)@(wild2_atV :: GHC.Prim.Int#) of
          _
          →
          case (GHC.Prim.># wild2_atV 0)@(wild_Xw Dead :: GHC.Bool.Bool) of
              [GHC.Bool.False] → GHC.Bool.True
              [GHC.Bool.True] → GHC.Bool.False

a_sAA :: (GHC.Prim.State# GHC.Prim.RealWorld) → (#GHC.Prim.State# GHC.Prim.RealWorld, ()#)
Arity 1
a_sAA
= λ(eta1_aum :: GHC.Prim.State# GHC.Prim.RealWorld) →
   case
   (GHC.IO.a25 GHC.Handle.stdout (GHC.Base.: GHC.Base.Char GHC.Show.a77 (GHC.Show.showl (GHC.Base.unpackCString# "Hello World") (GHC.Base.[] GHC.Base.Char))) eta1_aum)@(wild_aAn Dead :: (#GHC.Prim.State#
                                                                                                                                                                                            GHC.Prim.RealWorld,
                                                                                                                                                                                            ()#))
   of  (#new_s_aAp, a59_aAq Dead#) → GHC.IO.$wa13 GHC.Handle.stdout '
' new_s_aAp

Main.main_r72 :: GHC.IOBase.IO ()
[Exported]
Arity 1
Main.main_r72 = a_sAA ▶ (GHC.Prim.sym (GHC.IOBase.:CoIO ()))

a_sAC :: (GHC.Prim.State# GHC.Prim.RealWorld) → (#GHC.Prim.State# GHC.Prim.RealWorld, ()#)
Arity 1
a_sAC = GHC.TopHandler.a6 () (a_sAA ▶ (GHC.Prim.sym (GHC.IOBase.:CoIO ())))

:Main.main :: GHC.IOBase.IO ()
[Exported]
Arity 1
:Main.main = a_sAC ▶ (GHC.Prim.sym (GHC.IOBase.:CoIO ()))

Simplify


Main.my_foldr_r71 :: ∀t_a7l. ∀t_a7q. (t_a7q → t_a7l → t_a7l) → t_a7l → [t_a7q] → t_a7l
[Exported]
Arity 3
Main.my_foldr_r71
= Λ(t_a7l :: GHC.Prim.*) →
   Λ(t_a7q :: GHC.Prim.*) →
    λ(c_a77 :: t_a7q → t_a7l → t_a7l) →
     λ(n_a79 :: t_a7l) →
      λ(eta_srZ :: [t_a7q]) →
           letrec
                 my_foldr'_ssD LoopBreaker :: [t_a7q] → t_a7l
                 Arity 1
                 my_foldr'_ssD LoopBreaker
                 = λ(ds_drR :: [t_a7q]) →
                    case ds_drR@(wild_B1 :: [t_a7q]) of
                        [GHC.Base.[]] → n_a79
                        [GHC.Base.: x_a7d xs_a7f] → c_a77 x_a7d (my_foldr'_ssD xs_a7f)
       in my_foldr'_ssD eta_srZ

Main.my_id_r6X :: ∀t_alK. t_alK → t_alK
[Exported]
Arity 1
Main.my_id_r6X = Λ(t_alK :: GHC.Prim.*) → λ(x_a75 :: t_alK) → x_a75

Main.foo_r8 :: GHC.Integer.Integer
[Exported]
Main.foo_r8 = GHC.Integer.plusInteger (GHC.Integer.S# 1) (GHC.Integer.S# 1)

Main.bar_r73 :: GHC.Bool.Bool
[Exported]
Main.bar_r73
= case Main.foo_r8@(wild_atA :: GHC.Integer.Integer) of
      [GHC.Integer.S# i_atC]
      →
      case (GHC.Prim.># i_atC 2)@(wild_Xw Dead :: GHC.Bool.Bool) of
          [GHC.Bool.False] → GHC.Bool.True
          [GHC.Bool.True] → GHC.Bool.False
      [GHC.Integer.J# s_atO d_atP]
      →
      case (GHC.Prim.cmpIntegerInt# s_atO d_atP 2)@(wild2_atV :: GHC.Prim.Int#) of
          _
          →
          case (GHC.Prim.># wild2_atV 0)@(wild_Xw Dead :: GHC.Bool.Bool) of
              [GHC.Bool.False] → GHC.Bool.True
              [GHC.Bool.True] → GHC.Bool.False

a_sAA :: (GHC.Prim.State# GHC.Prim.RealWorld) → (#GHC.Prim.State# GHC.Prim.RealWorld, ()#)
Arity 1
a_sAA
= λ(eta1_aum :: GHC.Prim.State# GHC.Prim.RealWorld) →
   case
   (GHC.IO.a25 GHC.Handle.stdout (GHC.Base.: GHC.Base.Char GHC.Show.a77 (GHC.Show.showl (GHC.Base.unpackCString# "Hello World") (GHC.Base.[] GHC.Base.Char))) eta1_aum)@(wild_aAn Dead :: (#GHC.Prim.State#
                                                                                                                                                                                            GHC.Prim.RealWorld,
                                                                                                                                                                                            ()#))
   of  (#new_s_aAp, a59_aAq Dead#) → GHC.IO.$wa13 GHC.Handle.stdout '
' new_s_aAp

Main.main_r72 :: GHC.IOBase.IO ()
[Exported]
Arity 1
Main.main_r72 = a_sAA ▶ (GHC.Prim.sym (GHC.IOBase.:CoIO ()))

a_sAC :: (GHC.Prim.State# GHC.Prim.RealWorld) → (#GHC.Prim.State# GHC.Prim.RealWorld, ()#)
Arity 1
a_sAC = GHC.TopHandler.a6 () (a_sAA ▶ (GHC.Prim.sym (GHC.IOBase.:CoIO ())))

:Main.main :: GHC.IOBase.IO ()
[Exported]
Arity 1
:Main.main = a_sAC ▶ (GHC.Prim.sym (GHC.IOBase.:CoIO ()))

Demand Analysis


Main.my_foldr_r71 :: ∀t_a7l. ∀t_a7q. (t_a7q → t_a7l → t_a7l) → t_a7l → [t_a7q] → t_a7l
[Exported]
Arity 3
Str: DmdType LLS
Main.my_foldr_r71
= Λ(t_a7l :: GHC.Prim.*) →
   Λ(t_a7q :: GHC.Prim.*) →
    λ(c_a77 Just L :: t_a7q → t_a7l → t_a7l) →
     λ(n_a79 Just L :: t_a7l) →
      λ(eta_srZ Just S :: [t_a7q]) →
           letrec
                 my_foldr'_ssD LoopBreaker :: [t_a7q] → t_a7l
                 Arity 1
                 Str: DmdType S
                 my_foldr'_ssD LoopBreaker
                 = λ(ds_drR Just S :: [t_a7q]) →
                    case ds_drR@(wild_B1 Just A :: [t_a7q]) of
                        [GHC.Base.[]] → n_a79
                        [GHC.Base.: x_a7d Just L xs_a7f Just L] → c_a77 x_a7d (my_foldr'_ssD xs_a7f)
       in my_foldr'_ssD eta_srZ

Main.my_id_r6X :: ∀t_alK. t_alK → t_alK
[Exported]
Arity 1
Str: DmdType S
Main.my_id_r6X = Λ(t_alK :: GHC.Prim.*) → λ(x_a75 Just S :: t_alK) → x_a75

Main.foo_r8 :: GHC.Integer.Integer
[Exported]
Str: DmdType
Main.foo_r8 = GHC.Integer.plusInteger (GHC.Integer.S# 1) (GHC.Integer.S# 1)

Main.bar_r73 :: GHC.Bool.Bool
[Exported]
Str: DmdType
Main.bar_r73
= case Main.foo_r8@(wild_atA Just A :: GHC.Integer.Integer) of
      [GHC.Integer.S# i_atC Just L]
      →
      case (GHC.Prim.># i_atC 2)@(wild_Xw Dead Just A :: GHC.Bool.Bool) of
          [GHC.Bool.False] → GHC.Bool.True
          [GHC.Bool.True] → GHC.Bool.False
      [GHC.Integer.J# s_atO Just L d_atP Just L]
      →
      case (GHC.Prim.cmpIntegerInt# s_atO d_atP 2)@(wild2_atV Just L :: GHC.Prim.Int#) of
          _
          →
          case (GHC.Prim.># wild2_atV 0)@(wild_Xw Dead Just A :: GHC.Bool.Bool) of
              [GHC.Bool.False] → GHC.Bool.True
              [GHC.Bool.True] → GHC.Bool.False

a_sAA :: (GHC.Prim.State# GHC.Prim.RealWorld) → (#GHC.Prim.State# GHC.Prim.RealWorld, ()#)
Arity 1
Str: DmdType L
a_sAA
= λ(eta1_aum Just L :: GHC.Prim.State# GHC.Prim.RealWorld) →
   case
   (GHC.IO.a25 GHC.Handle.stdout (GHC.Base.: GHC.Base.Char GHC.Show.a77 (GHC.Show.showl (GHC.Base.unpackCString# "Hello World") (GHC.Base.[] GHC.Base.Char))) eta1_aum)@(wild_aAn Dead Just A :: (#GHC.Prim.State#
                                                                                                                                                                                                   GHC.Prim.RealWorld,
                                                                                                                                                                                                   ()#))
   of  (#new_s_aAp Just L, a59_aAq Dead Just A#) → GHC.IO.$wa13 GHC.Handle.stdout '
' new_s_aAp

Main.main_r72 :: GHC.IOBase.IO ()
[Exported]
Arity 1
Str: DmdType L
Main.main_r72 = a_sAA ▶ (GHC.Prim.sym (GHC.IOBase.:CoIO ()))

a_sAC :: (GHC.Prim.State# GHC.Prim.RealWorld) → (#GHC.Prim.State# GHC.Prim.RealWorld, ()#)
Arity 1
Str: DmdType L
a_sAC = GHC.TopHandler.a6 () (a_sAA ▶ (GHC.Prim.sym (GHC.IOBase.:CoIO ())))

:Main.main :: GHC.IOBase.IO ()
[Exported]
Arity 1
Str: DmdType L
:Main.main = a_sAC ▶ (GHC.Prim.sym (GHC.IOBase.:CoIO ()))

Worker-Wrapper


Main.my_foldr_r71 :: ∀t_a7l. ∀t_a7q. (t_a7q → t_a7l → t_a7l) → t_a7l → [t_a7q] → t_a7l
[Exported]
Arity 3
Str: DmdType LLS
Main.my_foldr_r71
= Λ(t_a7l :: GHC.Prim.*) →
   Λ(t_a7q :: GHC.Prim.*) →
    λ(c_a77 Just L :: t_a7q → t_a7l → t_a7l) →
     λ(n_a79 Just L :: t_a7l) →
      λ(eta_srZ Just S :: [t_a7q]) →
           letrec
                 my_foldr'_ssD LoopBreaker :: [t_a7q] → t_a7l
                 Arity 1
                 Str: DmdType S
                 my_foldr'_ssD LoopBreaker
                 = λ(ds_drR Just S :: [t_a7q]) →
                    case ds_drR@(wild_B1 Just A :: [t_a7q]) of
                        [GHC.Base.[]] → n_a79
                        [GHC.Base.: x_a7d Just L xs_a7f Just L] → c_a77 x_a7d (my_foldr'_ssD xs_a7f)
       in my_foldr'_ssD eta_srZ

Main.my_id_r6X :: ∀t_alK. t_alK → t_alK
[Exported]
Arity 1
Str: DmdType S
Main.my_id_r6X = Λ(t_alK :: GHC.Prim.*) → λ(x_a75 Just S :: t_alK) → x_a75

Main.foo_r8 :: GHC.Integer.Integer
[Exported]
Str: DmdType
Main.foo_r8 = GHC.Integer.plusInteger (GHC.Integer.S# 1) (GHC.Integer.S# 1)

Main.bar_r73 :: GHC.Bool.Bool
[Exported]
Str: DmdType
Main.bar_r73
= case Main.foo_r8@(wild_atA Just A :: GHC.Integer.Integer) of
      [GHC.Integer.S# i_atC Just L]
      →
      case (GHC.Prim.># i_atC 2)@(wild_Xw Dead Just A :: GHC.Bool.Bool) of
          [GHC.Bool.False] → GHC.Bool.True
          [GHC.Bool.True] → GHC.Bool.False
      [GHC.Integer.J# s_atO Just L d_atP Just L]
      →
      case (GHC.Prim.cmpIntegerInt# s_atO d_atP 2)@(wild2_atV Just L :: GHC.Prim.Int#) of
          _
          →
          case (GHC.Prim.># wild2_atV 0)@(wild_Xw Dead Just A :: GHC.Bool.Bool) of
              [GHC.Bool.False] → GHC.Bool.True
              [GHC.Bool.True] → GHC.Bool.False

a_sAA :: (GHC.Prim.State# GHC.Prim.RealWorld) → (#GHC.Prim.State# GHC.Prim.RealWorld, ()#)
Arity 1
Str: DmdType L
a_sAA
= λ(eta1_aum Just L :: GHC.Prim.State# GHC.Prim.RealWorld) →
   case
   (GHC.IO.a25 GHC.Handle.stdout (GHC.Base.: GHC.Base.Char GHC.Show.a77 (GHC.Show.showl (GHC.Base.unpackCString# "Hello World") (GHC.Base.[] GHC.Base.Char))) eta1_aum)@(wild_aAn Dead Just A :: (#GHC.Prim.State#
                                                                                                                                                                                                   GHC.Prim.RealWorld,
                                                                                                                                                                                                   ()#))
   of  (#new_s_aAp Just L, a59_aAq Dead Just A#) → GHC.IO.$wa13 GHC.Handle.stdout '
' new_s_aAp

Main.main_r72 :: GHC.IOBase.IO ()
[Exported]
Arity 1
Str: DmdType L
Main.main_r72 = a_sAA ▶ (GHC.Prim.sym (GHC.IOBase.:CoIO ()))

a_sAC :: (GHC.Prim.State# GHC.Prim.RealWorld) → (#GHC.Prim.State# GHC.Prim.RealWorld, ()#)
Arity 1
Str: DmdType L
a_sAC = GHC.TopHandler.a6 () (a_sAA ▶ (GHC.Prim.sym (GHC.IOBase.:CoIO ())))

:Main.main :: GHC.IOBase.IO ()
[Exported]
Arity 1
Str: DmdType L
:Main.main = a_sAC ▶ (GHC.Prim.sym (GHC.IOBase.:CoIO ()))

Bind Glomming


Main.my_foldr_r71 :: ∀t_a7l. ∀t_a7q. (t_a7q → t_a7l → t_a7l) → t_a7l → [t_a7q] → t_a7l
[Exported]
Arity 3
Str: DmdType LLS
Main.my_foldr_r71
= Λ(t_a7l :: GHC.Prim.*) →
   Λ(t_a7q :: GHC.Prim.*) →
    λ(c_a77 Just L :: t_a7q → t_a7l → t_a7l) →
     λ(n_a79 Just L :: t_a7l) →
      λ(eta_srZ Just S :: [t_a7q]) →
           letrec
                 my_foldr'_ssD LoopBreaker :: [t_a7q] → t_a7l
                 Arity 1
                 Str: DmdType S
                 my_foldr'_ssD LoopBreaker
                 = λ(ds_drR Just S :: [t_a7q]) →
                    case ds_drR@(wild_B1 Just A :: [t_a7q]) of
                        [GHC.Base.[]] → n_a79
                        [GHC.Base.: x_a7d Just L xs_a7f Just L] → c_a77 x_a7d (my_foldr'_ssD xs_a7f)
       in my_foldr'_ssD eta_srZ

Main.my_id_r6X :: ∀t_alK. t_alK → t_alK
[Exported]
Arity 1
Str: DmdType S
Main.my_id_r6X = Λ(t_alK :: GHC.Prim.*) → λ(x_a75 Just S :: t_alK) → x_a75

Main.foo_r8 :: GHC.Integer.Integer
[Exported]
Str: DmdType
Main.foo_r8 = GHC.Integer.plusInteger (GHC.Integer.S# 1) (GHC.Integer.S# 1)

Main.bar_r73 :: GHC.Bool.Bool
[Exported]
Str: DmdType
Main.bar_r73
= case Main.foo_r8@(wild_atA Just A :: GHC.Integer.Integer) of
      [GHC.Integer.S# i_atC Just L]
      →
      case (GHC.Prim.># i_atC 2)@(wild_Xw Dead Just A :: GHC.Bool.Bool) of
          [GHC.Bool.False] → GHC.Bool.True
          [GHC.Bool.True] → GHC.Bool.False
      [GHC.Integer.J# s_atO Just L d_atP Just L]
      →
      case (GHC.Prim.cmpIntegerInt# s_atO d_atP 2)@(wild2_atV Just L :: GHC.Prim.Int#) of
          _
          →
          case (GHC.Prim.># wild2_atV 0)@(wild_Xw Dead Just A :: GHC.Bool.Bool) of
              [GHC.Bool.False] → GHC.Bool.True
              [GHC.Bool.True] → GHC.Bool.False

a_sAA :: (GHC.Prim.State# GHC.Prim.RealWorld) → (#GHC.Prim.State# GHC.Prim.RealWorld, ()#)
Arity 1
Str: DmdType L
a_sAA
= λ(eta1_aum Just L :: GHC.Prim.State# GHC.Prim.RealWorld) →
   case
   (GHC.IO.a25 GHC.Handle.stdout (GHC.Base.: GHC.Base.Char GHC.Show.a77 (GHC.Show.showl (GHC.Base.unpackCString# "Hello World") (GHC.Base.[] GHC.Base.Char))) eta1_aum)@(wild_aAn Dead Just A :: (#GHC.Prim.State#
                                                                                                                                                                                                   GHC.Prim.RealWorld,
                                                                                                                                                                                                   ()#))
   of  (#new_s_aAp Just L, a59_aAq Dead Just A#) → GHC.IO.$wa13 GHC.Handle.stdout '
' new_s_aAp

Main.main_r72 :: GHC.IOBase.IO ()
[Exported]
Arity 1
Str: DmdType L
Main.main_r72 = a_sAA ▶ (GHC.Prim.sym (GHC.IOBase.:CoIO ()))

a_sAC :: (GHC.Prim.State# GHC.Prim.RealWorld) → (#GHC.Prim.State# GHC.Prim.RealWorld, ()#)
Arity 1
Str: DmdType L
a_sAC = GHC.TopHandler.a6 () (a_sAA ▶ (GHC.Prim.sym (GHC.IOBase.:CoIO ())))

:Main.main :: GHC.IOBase.IO ()
[Exported]
Arity 1
Str: DmdType L
:Main.main = a_sAC ▶ (GHC.Prim.sym (GHC.IOBase.:CoIO ()))

Simplify


a_sAA :: (GHC.Prim.State# GHC.Prim.RealWorld) → (#GHC.Prim.State# GHC.Prim.RealWorld, ()#)
Arity 1
Str: DmdType L
a_sAA
= λ(eta1_aum :: GHC.Prim.State# GHC.Prim.RealWorld) →
   case
   (GHC.IO.a25 GHC.Handle.stdout (GHC.Base.: GHC.Base.Char GHC.Show.a77 (GHC.Show.showl (GHC.Base.unpackCString# "Hello World") (GHC.Base.[] GHC.Base.Char))) eta1_aum)@(wild_aAn Dead Just A :: (#GHC.Prim.State#
                                                                                                                                                                                                   GHC.Prim.RealWorld,
                                                                                                                                                                                                   ()#))
   of  (#new_s_aAp Just L, a59_aAq Dead Just A#) → GHC.IO.$wa13 GHC.Handle.stdout '
' new_s_aAp

a_sAC :: (GHC.Prim.State# GHC.Prim.RealWorld) → (#GHC.Prim.State# GHC.Prim.RealWorld, ()#)
Arity 1
Str: DmdType L
a_sAC = GHC.TopHandler.a6 () (a_sAA ▶ (GHC.Prim.sym (GHC.IOBase.:CoIO ())))

Main.main_r72 :: GHC.IOBase.IO ()
[Exported]
Arity 1
Str: DmdType L
Main.main_r72 = a_sAA ▶ (GHC.Prim.sym (GHC.IOBase.:CoIO ()))

Main.my_foldr_r71 :: ∀t_a7l. ∀t_a7q. (t_a7q → t_a7l → t_a7l) → t_a7l → [t_a7q] → t_a7l
[Exported]
Arity 3
Str: DmdType LLS
Main.my_foldr_r71
= Λ(t_a7l :: GHC.Prim.*) →
   Λ(t_a7q :: GHC.Prim.*) →
    λ(c_a77 Just L :: t_a7q → t_a7l → t_a7l) →
     λ(n_a79 Just L :: t_a7l) →
      λ(eta_srZ :: [t_a7q]) →
           letrec
                 my_foldr'_ssD LoopBreaker :: [t_a7q] → t_a7l
                 Arity 1
                 Str: DmdType S
                 my_foldr'_ssD LoopBreaker
                 = λ(ds_drR :: [t_a7q]) →
                    case ds_drR@(wild_B1 Just A :: [t_a7q]) of
                        [GHC.Base.[]] → n_a79
                        [GHC.Base.: x_a7d Just L xs_a7f Just L] → c_a77 x_a7d (my_foldr'_ssD xs_a7f)
       in my_foldr'_ssD eta_srZ

Main.my_id_r6X :: ∀t_alK. t_alK → t_alK
[Exported]
Arity 1
Str: DmdType S
Main.my_id_r6X = Λ(t_alK :: GHC.Prim.*) → λ(x_a75 :: t_alK) → x_a75

Main.foo_r8 :: GHC.Integer.Integer
[Exported]
Str: DmdType
Main.foo_r8 = GHC.Integer.plusInteger (GHC.Integer.S# 1) (GHC.Integer.S# 1)

Main.bar_r73 :: GHC.Bool.Bool
[Exported]
Str: DmdType
Main.bar_r73
= case Main.foo_r8@(wild_atA Just A :: GHC.Integer.Integer) of
      [GHC.Integer.S# i_atC Just L]
      →
      case (GHC.Prim.># i_atC 2)@(wild_Xw Dead Just A :: GHC.Bool.Bool) of
          [GHC.Bool.False] → GHC.Bool.True
          [GHC.Bool.True] → GHC.Bool.False
      [GHC.Integer.J# s_atO Just L d_atP Just L]
      →
      case (GHC.Prim.cmpIntegerInt# s_atO d_atP 2)@(wild2_atV Just L :: GHC.Prim.Int#) of
          _
          →
          case (GHC.Prim.># wild2_atV 0)@(wild_Xw Dead Just A :: GHC.Bool.Bool) of
              [GHC.Bool.False] → GHC.Bool.True
              [GHC.Bool.True] → GHC.Bool.False

:Main.main :: GHC.IOBase.IO ()
[Exported]
Arity 1
Str: DmdType L
:Main.main = a_sAC ▶ (GHC.Prim.sym (GHC.IOBase.:CoIO ()))

Float Outwards


lvl_sBs :: [GHC.Base.Char]
lvl_sBs = GHC.Base.unpackCString# "Hello World"

lvl_sBr :: GHC.Base.String
lvl_sBr = GHC.Show.showl lvl_sBs (GHC.Base.[] GHC.Base.Char)

lvl_sBq :: [GHC.Base.Char]
lvl_sBq = GHC.Base.: GHC.Base.Char GHC.Show.a77 lvl_sBr

a_sAA :: (GHC.Prim.State# GHC.Prim.RealWorld) → (#GHC.Prim.State# GHC.Prim.RealWorld, ()#)
Arity 1
Str: DmdType L
a_sAA
= λ(eta1_aum :: GHC.Prim.State# GHC.Prim.RealWorld) →
   case (GHC.IO.a25 GHC.Handle.stdout lvl_sBq eta1_aum)@(wild_aAn Dead Just A :: (#GHC.Prim.State# GHC.Prim.RealWorld, ()#)) of (#new_s_aAp Just L, a59_aAq Dead Just A#) → GHC.IO.$wa13 GHC.Handle.stdout '
' new_s_aAp

a_sAC :: (GHC.Prim.State# GHC.Prim.RealWorld) → (#GHC.Prim.State# GHC.Prim.RealWorld, ()#)
Arity 1
Str: DmdType L
a_sAC = GHC.TopHandler.a6 () (a_sAA ▶ (GHC.Prim.sym (GHC.IOBase.:CoIO ())))

Main.main_r72 :: GHC.IOBase.IO ()
[Exported]
Arity 1
Str: DmdType L
Main.main_r72 = a_sAA ▶ (GHC.Prim.sym (GHC.IOBase.:CoIO ()))

Main.my_foldr_r71 :: ∀t_a7l. ∀t_a7q. (t_a7q → t_a7l → t_a7l) → t_a7l → [t_a7q] → t_a7l
[Exported]
Arity 3
Str: DmdType LLS
Main.my_foldr_r71
= Λ(t_a7l :: GHC.Prim.*) →
   Λ(t_a7q :: GHC.Prim.*) →
    λ(c_a77 Just L :: t_a7q → t_a7l → t_a7l) →
     λ(n_a79 Just L :: t_a7l) →
      λ(eta_srZ :: [t_a7q]) →
           letrec
                 my_foldr'_sBn LoopBreaker :: [t_a7q] → t_a7l
                 Arity 1
                 Str: DmdType S
                 my_foldr'_sBn LoopBreaker
                 = λ(ds_drR :: [t_a7q]) →
                    case ds_drR@(wild_B1 Just A :: [t_a7q]) of
                        [GHC.Base.[]] → n_a79
                        [GHC.Base.: x_a7d Just L xs_a7f Just L] → c_a77 x_a7d (my_foldr'_sBn xs_a7f)
       in my_foldr'_sBn eta_srZ

Main.my_id_r6X :: ∀t_alK. t_alK → t_alK
[Exported]
Arity 1
Str: DmdType S
Main.my_id_r6X = Λ(t_alK :: GHC.Prim.*) → λ(x_a75 :: t_alK) → x_a75

lvl_sBt :: GHC.Integer.Integer
lvl_sBt = GHC.Integer.S# 1

lvl_sBu :: GHC.Integer.Integer
lvl_sBu = GHC.Integer.S# 1

Main.foo_r8 :: GHC.Integer.Integer
[Exported]
Str: DmdType
Main.foo_r8 = GHC.Integer.plusInteger lvl_sBt lvl_sBu

Main.bar_r73 :: GHC.Bool.Bool
[Exported]
Str: DmdType
Main.bar_r73
= case Main.foo_r8@(wild_atA Just A :: GHC.Integer.Integer) of
      [GHC.Integer.S# i_atC Just L]
      →
      case (GHC.Prim.># i_atC 2)@(wild_Xw Dead Just A :: GHC.Bool.Bool) of
          [GHC.Bool.False] → GHC.Bool.True
          [GHC.Bool.True] → GHC.Bool.False
      [GHC.Integer.J# s_atO Just L d_atP Just L]
      →
      case (GHC.Prim.cmpIntegerInt# s_atO d_atP 2)@(wild2_atV Just L :: GHC.Prim.Int#) of
          _
          →
          case (GHC.Prim.># wild2_atV 0)@(wild_Xw Dead Just A :: GHC.Bool.Bool) of
              [GHC.Bool.False] → GHC.Bool.True
              [GHC.Bool.True] → GHC.Bool.False

:Main.main :: GHC.IOBase.IO ()
[Exported]
Arity 1
Str: DmdType L
:Main.main = a_sAC ▶ (GHC.Prim.sym (GHC.IOBase.:CoIO ()))

Common Subexpression Elimination


lvl_sBs :: [GHC.Base.Char]
lvl_sBs = GHC.Base.unpackCString# "Hello World"

lvl_sBr :: GHC.Base.String
lvl_sBr = GHC.Show.showl lvl_sBs (GHC.Base.[] GHC.Base.Char)

lvl_sBq :: [GHC.Base.Char]
lvl_sBq = GHC.Base.: GHC.Base.Char GHC.Show.a77 lvl_sBr

a_sAA :: (GHC.Prim.State# GHC.Prim.RealWorld) → (#GHC.Prim.State# GHC.Prim.RealWorld, ()#)
Arity 1
Str: DmdType L
a_sAA
= λ(eta1_aum :: GHC.Prim.State# GHC.Prim.RealWorld) →
   case (GHC.IO.a25 GHC.Handle.stdout lvl_sBq eta1_aum)@(wild_aAn Dead Just A :: (#GHC.Prim.State# GHC.Prim.RealWorld, ()#)) of (#new_s_aAp Just L, a59_aAq Dead Just A#) → GHC.IO.$wa13 GHC.Handle.stdout '
' new_s_aAp

a_sAC :: (GHC.Prim.State# GHC.Prim.RealWorld) → (#GHC.Prim.State# GHC.Prim.RealWorld, ()#)
Arity 1
Str: DmdType L
a_sAC = GHC.TopHandler.a6 () (a_sAA ▶ (GHC.Prim.sym (GHC.IOBase.:CoIO ())))

Main.main_r72 :: GHC.IOBase.IO ()
[Exported]
Arity 1
Str: DmdType L
Main.main_r72 = a_sAA ▶ (GHC.Prim.sym (GHC.IOBase.:CoIO ()))

Main.my_foldr_r71 :: ∀t_a7l. ∀t_a7q. (t_a7q → t_a7l → t_a7l) → t_a7l → [t_a7q] → t_a7l
[Exported]
Arity 3
Str: DmdType LLS
Main.my_foldr_r71
= Λ(t_a7l :: GHC.Prim.*) →
   Λ(t_a7q :: GHC.Prim.*) →
    λ(c_a77 Just L :: t_a7q → t_a7l → t_a7l) →
     λ(n_a79 Just L :: t_a7l) →
      λ(eta_srZ :: [t_a7q]) →
           letrec
                 my_foldr'_sBn LoopBreaker :: [t_a7q] → t_a7l
                 Arity 1
                 Str: DmdType S
                 my_foldr'_sBn LoopBreaker
                 = λ(ds_drR :: [t_a7q]) →
                    case ds_drR@(wild_B1 Just A :: [t_a7q]) of
                        [GHC.Base.[]] → n_a79
                        [GHC.Base.: x_a7d Just L xs_a7f Just L] → c_a77 x_a7d (my_foldr'_sBn xs_a7f)
       in my_foldr'_sBn eta_srZ

Main.my_id_r6X :: ∀t_alK. t_alK → t_alK
[Exported]
Arity 1
Str: DmdType S
Main.my_id_r6X = Λ(t_alK :: GHC.Prim.*) → λ(x_a75 :: t_alK) → x_a75

lvl_sBt :: GHC.Integer.Integer
lvl_sBt = GHC.Integer.S# 1

lvl_sBu :: GHC.Integer.Integer
lvl_sBu = lvl_sBt

Main.foo_r8 :: GHC.Integer.Integer
[Exported]
Str: DmdType
Main.foo_r8 = GHC.Integer.plusInteger lvl_sBt lvl_sBt

Main.bar_r73 :: GHC.Bool.Bool
[Exported]
Str: DmdType
Main.bar_r73
= case Main.foo_r8@(wild_atA Just A :: GHC.Integer.Integer) of
      [GHC.Integer.S# i_atC Just L]
      →
      case (GHC.Prim.># i_atC 2)@(wild_Xw Dead Just A :: GHC.Bool.Bool) of
          [GHC.Bool.False] → GHC.Bool.True
          [GHC.Bool.True] → GHC.Bool.False
      [GHC.Integer.J# s_atO Just L d_atP Just L]
      →
      case (GHC.Prim.cmpIntegerInt# s_atO d_atP 2)@(wild2_atV Just L :: GHC.Prim.Int#) of
          _
          →
          case (GHC.Prim.># wild2_atV 0)@(wild_Xw Dead Just A :: GHC.Bool.Bool) of
              [GHC.Bool.False] → GHC.Bool.True
              [GHC.Bool.True] → GHC.Bool.False

:Main.main :: GHC.IOBase.IO ()
[Exported]
Arity 1
Str: DmdType L
:Main.main = a_sAC ▶ (GHC.Prim.sym (GHC.IOBase.:CoIO ()))

Float Inwards


lvl_sBs :: [GHC.Base.Char]
lvl_sBs = GHC.Base.unpackCString# "Hello World"

lvl_sBr :: GHC.Base.String
lvl_sBr = GHC.Show.showl lvl_sBs (GHC.Base.[] GHC.Base.Char)

lvl_sBq :: [GHC.Base.Char]
lvl_sBq = GHC.Base.: GHC.Base.Char GHC.Show.a77 lvl_sBr

a_sAA :: (GHC.Prim.State# GHC.Prim.RealWorld) → (#GHC.Prim.State# GHC.Prim.RealWorld, ()#)
Arity 1
Str: DmdType L
a_sAA
= λ(eta1_aum :: GHC.Prim.State# GHC.Prim.RealWorld) →
   case (GHC.IO.a25 GHC.Handle.stdout lvl_sBq eta1_aum)@(wild_aAn Dead Just A :: (#GHC.Prim.State# GHC.Prim.RealWorld, ()#)) of (#new_s_aAp Just L, a59_aAq Dead Just A#) → GHC.IO.$wa13 GHC.Handle.stdout '
' new_s_aAp

a_sAC :: (GHC.Prim.State# GHC.Prim.RealWorld) → (#GHC.Prim.State# GHC.Prim.RealWorld, ()#)
Arity 1
Str: DmdType L
a_sAC = GHC.TopHandler.a6 () (a_sAA ▶ (GHC.Prim.sym (GHC.IOBase.:CoIO ())))

Main.main_r72 :: GHC.IOBase.IO ()
[Exported]
Arity 1
Str: DmdType L
Main.main_r72 = a_sAA ▶ (GHC.Prim.sym (GHC.IOBase.:CoIO ()))

Main.my_foldr_r71 :: ∀t_a7l. ∀t_a7q. (t_a7q → t_a7l → t_a7l) → t_a7l → [t_a7q] → t_a7l
[Exported]
Arity 3
Str: DmdType LLS
Main.my_foldr_r71
= Λ(t_a7l :: GHC.Prim.*) →
   Λ(t_a7q :: GHC.Prim.*) →
    λ(c_a77 Just L :: t_a7q → t_a7l → t_a7l) →
     λ(n_a79 Just L :: t_a7l) →
      λ(eta_srZ :: [t_a7q]) →
           letrec
                 my_foldr'_sBn LoopBreaker :: [t_a7q] → t_a7l
                 Arity 1
                 Str: DmdType S
                 my_foldr'_sBn LoopBreaker
                 = λ(ds_drR :: [t_a7q]) →
                    case ds_drR@(wild_B1 Just A :: [t_a7q]) of
                        [GHC.Base.[]] → n_a79
                        [GHC.Base.: x_a7d Just L xs_a7f Just L] → c_a77 x_a7d (my_foldr'_sBn xs_a7f)
       in my_foldr'_sBn
       eta_srZ

Main.my_id_r6X :: ∀t_alK. t_alK → t_alK
[Exported]
Arity 1
Str: DmdType S
Main.my_id_r6X = Λ(t_alK :: GHC.Prim.*) → λ(x_a75 :: t_alK) → x_a75

lvl_sBt :: GHC.Integer.Integer
lvl_sBt = GHC.Integer.S# 1

lvl_sBu :: GHC.Integer.Integer
lvl_sBu = lvl_sBt

Main.foo_r8 :: GHC.Integer.Integer
[Exported]
Str: DmdType
Main.foo_r8 = GHC.Integer.plusInteger lvl_sBt lvl_sBt

Main.bar_r73 :: GHC.Bool.Bool
[Exported]
Str: DmdType
Main.bar_r73
= case Main.foo_r8@(wild_atA Just A :: GHC.Integer.Integer) of
      [GHC.Integer.S# i_atC Just L]
      →
      case (GHC.Prim.># i_atC 2)@(wild_Xw Dead Just A :: GHC.Bool.Bool) of
          [GHC.Bool.False] → GHC.Bool.True
          [GHC.Bool.True] → GHC.Bool.False
      [GHC.Integer.J# s_atO Just L d_atP Just L]
      →
      case (GHC.Prim.cmpIntegerInt# s_atO d_atP 2)@(wild2_atV Just L :: GHC.Prim.Int#) of
          _
          →
          case (GHC.Prim.># wild2_atV 0)@(wild_Xw Dead Just A :: GHC.Bool.Bool) of
              [GHC.Bool.False] → GHC.Bool.True
              [GHC.Bool.True] → GHC.Bool.False

:Main.main :: GHC.IOBase.IO ()
[Exported]
Arity 1
Str: DmdType L
:Main.main = a_sAC ▶ (GHC.Prim.sym (GHC.IOBase.:CoIO ()))

Liberate Case


lvl_sBs :: [GHC.Base.Char]
lvl_sBs = GHC.Base.unpackCString# "Hello World"

lvl_sBr :: GHC.Base.String
lvl_sBr = GHC.Show.showl lvl_sBs (GHC.Base.[] GHC.Base.Char)

lvl_sBq :: [GHC.Base.Char]
lvl_sBq = GHC.Base.: GHC.Base.Char GHC.Show.a77 lvl_sBr

a_sAA :: (GHC.Prim.State# GHC.Prim.RealWorld) → (#GHC.Prim.State# GHC.Prim.RealWorld, ()#)
Arity 1
Str: DmdType L
a_sAA
= λ(eta1_aum :: GHC.Prim.State# GHC.Prim.RealWorld) →
   case (GHC.IO.a25 GHC.Handle.stdout lvl_sBq eta1_aum)@(wild_aAn Dead Just A :: (#GHC.Prim.State# GHC.Prim.RealWorld, ()#)) of (#new_s_aAp Just L, a59_aAq Dead Just A#) → GHC.IO.$wa13 GHC.Handle.stdout '
' new_s_aAp

a_sAC :: (GHC.Prim.State# GHC.Prim.RealWorld) → (#GHC.Prim.State# GHC.Prim.RealWorld, ()#)
Arity 1
Str: DmdType L
a_sAC = GHC.TopHandler.a6 () (a_sAA ▶ (GHC.Prim.sym (GHC.IOBase.:CoIO ())))

Main.main_r72 :: GHC.IOBase.IO ()
[Exported]
Arity 1
Str: DmdType L
Main.main_r72 = a_sAA ▶ (GHC.Prim.sym (GHC.IOBase.:CoIO ()))

Main.my_foldr_r71 :: ∀t_a7l. ∀t_a7q. (t_a7q → t_a7l → t_a7l) → t_a7l → [t_a7q] → t_a7l
[Exported]
Arity 3
Str: DmdType LLS
Main.my_foldr_r71
= Λ(t_a7l :: GHC.Prim.*) →
   Λ(t_a7q :: GHC.Prim.*) →
    λ(c_a77 Just L :: t_a7q → t_a7l → t_a7l) →
     λ(n_a79 Just L :: t_a7l) →
      λ(eta_srZ :: [t_a7q]) →
           letrec
                 my_foldr'_sBn LoopBreaker :: [t_a7q] → t_a7l
                 Arity 1
                 Str: DmdType S
                 my_foldr'_sBn LoopBreaker
                 = λ(ds_drR :: [t_a7q]) →
                    case ds_drR@(wild_B1 Just A :: [t_a7q]) of
                        [GHC.Base.[]] → n_a79
                        [GHC.Base.: x_a7d Just L xs_a7f Just L] → c_a77 x_a7d (my_foldr'_sBn xs_a7f)
       in my_foldr'_sBn
       eta_srZ

Main.my_id_r6X :: ∀t_alK. t_alK → t_alK
[Exported]
Arity 1
Str: DmdType S
Main.my_id_r6X = Λ(t_alK :: GHC.Prim.*) → λ(x_a75 :: t_alK) → x_a75

lvl_sBt :: GHC.Integer.Integer
lvl_sBt = GHC.Integer.S# 1

lvl_sBu :: GHC.Integer.Integer
lvl_sBu = lvl_sBt

Main.foo_r8 :: GHC.Integer.Integer
[Exported]
Str: DmdType
Main.foo_r8 = GHC.Integer.plusInteger lvl_sBt lvl_sBt

Main.bar_r73 :: GHC.Bool.Bool
[Exported]
Str: DmdType
Main.bar_r73
= case Main.foo_r8@(wild_atA Just A :: GHC.Integer.Integer) of
      [GHC.Integer.S# i_atC Just L]
      →
      case (GHC.Prim.># i_atC 2)@(wild_Xw Dead Just A :: GHC.Bool.Bool) of
          [GHC.Bool.False] → GHC.Bool.True
          [GHC.Bool.True] → GHC.Bool.False
      [GHC.Integer.J# s_atO Just L d_atP Just L]
      →
      case (GHC.Prim.cmpIntegerInt# s_atO d_atP 2)@(wild2_atV Just L :: GHC.Prim.Int#) of
          _
          →
          case (GHC.Prim.># wild2_atV 0)@(wild_Xw Dead Just A :: GHC.Bool.Bool) of
              [GHC.Bool.False] → GHC.Bool.True
              [GHC.Bool.True] → GHC.Bool.False

:Main.main :: GHC.IOBase.IO ()
[Exported]
Arity 1
Str: DmdType L
:Main.main = a_sAC ▶ (GHC.Prim.sym (GHC.IOBase.:CoIO ()))

Simplify


lvl_sBs :: [GHC.Base.Char]
lvl_sBs = GHC.Base.unpackCString# "Hello World"

lvl_sBr :: GHC.Base.String
lvl_sBr = GHC.Show.showl lvl_sBs (GHC.Base.[] GHC.Base.Char)

lvl_sBq :: [GHC.Base.Char]
lvl_sBq = GHC.Base.: GHC.Base.Char GHC.Show.a77 lvl_sBr

a_sAA :: (GHC.Prim.State# GHC.Prim.RealWorld) → (#GHC.Prim.State# GHC.Prim.RealWorld, ()#)
Arity 1
Str: DmdType L
a_sAA
= λ(eta1_aum :: GHC.Prim.State# GHC.Prim.RealWorld) →
   case (GHC.IO.a25 GHC.Handle.stdout lvl_sBq eta1_aum)@(wild_aAn Dead Just A :: (#GHC.Prim.State# GHC.Prim.RealWorld, ()#)) of (#new_s_aAp Just L, a59_aAq Dead Just A#) → GHC.IO.$wa13 GHC.Handle.stdout '
' new_s_aAp

a_sAC :: (GHC.Prim.State# GHC.Prim.RealWorld) → (#GHC.Prim.State# GHC.Prim.RealWorld, ()#)
Arity 1
Str: DmdType L
a_sAC = GHC.TopHandler.a6 () (a_sAA ▶ (GHC.Prim.sym (GHC.IOBase.:CoIO ())))

Main.main_r72 :: GHC.IOBase.IO ()
[Exported]
Arity 1
Str: DmdType L
Main.main_r72 = a_sAA ▶ (GHC.Prim.sym (GHC.IOBase.:CoIO ()))

Main.my_foldr_r71 :: ∀t_a7l. ∀t_a7q. (t_a7q → t_a7l → t_a7l) → t_a7l → [t_a7q] → t_a7l
[Exported]
Arity 3
Str: DmdType LLS
Main.my_foldr_r71
= Λ(t_a7l :: GHC.Prim.*) →
   Λ(t_a7q :: GHC.Prim.*) →
    λ(c_a77 Just L :: t_a7q → t_a7l → t_a7l) →
     λ(n_a79 Just L :: t_a7l) →
      λ(eta_srZ :: [t_a7q]) →
           letrec
                 my_foldr'_sBn LoopBreaker :: [t_a7q] → t_a7l
                 Arity 1
                 Str: DmdType S
                 my_foldr'_sBn LoopBreaker
                 = λ(ds_drR :: [t_a7q]) →
                    case ds_drR@(wild_B1 Just A :: [t_a7q]) of
                        [GHC.Base.[]] → n_a79
                        [GHC.Base.: x_a7d Just L xs_a7f Just L] → c_a77 x_a7d (my_foldr'_sBn xs_a7f)
       in my_foldr'_sBn eta_srZ

Main.my_id_r6X :: ∀t_alK. t_alK → t_alK
[Exported]
Arity 1
Str: DmdType S
Main.my_id_r6X = Λ(t_alK :: GHC.Prim.*) → λ(x_a75 :: t_alK) → x_a75

lvl_sBt :: GHC.Integer.Integer
lvl_sBt = GHC.Integer.S# 1

Main.foo_r8 :: GHC.Integer.Integer
[Exported]
Str: DmdType
Main.foo_r8 = GHC.Integer.plusInteger lvl_sBt lvl_sBt

Main.bar_r73 :: GHC.Bool.Bool
[Exported]
Str: DmdType
Main.bar_r73
= case Main.foo_r8@(wild_atA Just A :: GHC.Integer.Integer) of
      [GHC.Integer.S# i_atC Just L]
      →
      case (GHC.Prim.># i_atC 2)@(wild_Xw Dead Just A :: GHC.Bool.Bool) of
          [GHC.Bool.False] → GHC.Bool.True
          [GHC.Bool.True] → GHC.Bool.False
      [GHC.Integer.J# s_atO Just L d_atP Just L]
      →
      case (GHC.Prim.cmpIntegerInt# s_atO d_atP 2)@(wild2_atV Just L :: GHC.Prim.Int#) of
          _
          →
          case (GHC.Prim.># wild2_atV 0)@(wild_Xw Dead Just A :: GHC.Bool.Bool) of
              [GHC.Bool.False] → GHC.Bool.True
              [GHC.Bool.True] → GHC.Bool.False

:Main.main :: GHC.IOBase.IO ()
[Exported]
Arity 1
Str: DmdType L
:Main.main = a_sAC ▶ (GHC.Prim.sym (GHC.IOBase.:CoIO ()))

Constructor Specialisation


lvl_sBs :: [GHC.Base.Char]
lvl_sBs = GHC.Base.unpackCString# "Hello World"

lvl_sBr :: GHC.Base.String
lvl_sBr = GHC.Show.showl lvl_sBs (GHC.Base.[] GHC.Base.Char)

lvl_sBq :: [GHC.Base.Char]
lvl_sBq = GHC.Base.: GHC.Base.Char GHC.Show.a77 lvl_sBr

a_sAA :: (GHC.Prim.State# GHC.Prim.RealWorld) → (#GHC.Prim.State# GHC.Prim.RealWorld, ()#)
Arity 1
Str: DmdType L
a_sAA
= λ(eta1_aum :: GHC.Prim.State# GHC.Prim.RealWorld) →
   case (GHC.IO.a25 GHC.Handle.stdout lvl_sBq eta1_aum)@(wild_aAn Dead Just A :: (#GHC.Prim.State# GHC.Prim.RealWorld, ()#)) of (#new_s_aAp Just L, a59_aAq Dead Just A#) → GHC.IO.$wa13 GHC.Handle.stdout '
' new_s_aAp

a_sAC :: (GHC.Prim.State# GHC.Prim.RealWorld) → (#GHC.Prim.State# GHC.Prim.RealWorld, ()#)
Arity 1
Str: DmdType L
a_sAC = GHC.TopHandler.a6 () (a_sAA ▶ (GHC.Prim.sym (GHC.IOBase.:CoIO ())))

Main.main_r72 :: GHC.IOBase.IO ()
[Exported]
Arity 1
Str: DmdType L
Main.main_r72 = a_sAA ▶ (GHC.Prim.sym (GHC.IOBase.:CoIO ()))

Main.my_foldr_r71 :: ∀t_a7l. ∀t_a7q. (t_a7q → t_a7l → t_a7l) → t_a7l → [t_a7q] → t_a7l
[Exported]
Arity 3
Str: DmdType LLS
Main.my_foldr_r71
= Λ(t_a7l :: GHC.Prim.*) →
   Λ(t_a7q :: GHC.Prim.*) →
    λ(c_a77 Just L :: t_a7q → t_a7l → t_a7l) →
     λ(n_a79 Just L :: t_a7l) →
      λ(eta_srZ :: [t_a7q]) →
           letrec
                 my_foldr'_sBn LoopBreaker :: [t_a7q] → t_a7l
                 Arity 1
                 Str: DmdType S
                 my_foldr'_sBn LoopBreaker
                 = λ(ds_drR :: [t_a7q]) →
                    case ds_drR@(wild_B1 Just A :: [t_a7q]) of
                        [GHC.Base.[]] → n_a79
                        [GHC.Base.: x_a7d Just L xs_a7f Just L] → c_a77 x_a7d (my_foldr'_sBn xs_a7f)
       in my_foldr'_sBn eta_srZ

Main.my_id_r6X :: ∀t_alK. t_alK → t_alK
[Exported]
Arity 1
Str: DmdType S
Main.my_id_r6X = Λ(t_alK :: GHC.Prim.*) → λ(x_a75 :: t_alK) → x_a75

lvl_sBt :: GHC.Integer.Integer
lvl_sBt = GHC.Integer.S# 1

Main.foo_r8 :: GHC.Integer.Integer
[Exported]
Str: DmdType
Main.foo_r8 = GHC.Integer.plusInteger lvl_sBt lvl_sBt

Main.bar_r73 :: GHC.Bool.Bool
[Exported]
Str: DmdType
Main.bar_r73
= case Main.foo_r8@(wild_atA Just A :: GHC.Integer.Integer) of
      [GHC.Integer.S# i_atC Just L]
      →
      case (GHC.Prim.># i_atC 2)@(wild_Xw Dead Just A :: GHC.Bool.Bool) of
          [GHC.Bool.False] → GHC.Bool.True
          [GHC.Bool.True] → GHC.Bool.False
      [GHC.Integer.J# s_atO Just L d_atP Just L]
      →
      case (GHC.Prim.cmpIntegerInt# s_atO d_atP 2)@(wild2_atV Just L :: GHC.Prim.Int#) of
          _
          →
          case (GHC.Prim.># wild2_atV 0)@(wild_Xw Dead Just A :: GHC.Bool.Bool) of
              [GHC.Bool.False] → GHC.Bool.True
              [GHC.Bool.True] → GHC.Bool.False

:Main.main :: GHC.IOBase.IO ()
[Exported]
Arity 1
Str: DmdType L
:Main.main = a_sAC ▶ (GHC.Prim.sym (GHC.IOBase.:CoIO ()))

Simplify


lvl_sBs :: [GHC.Base.Char]
lvl_sBs = GHC.Base.unpackCString# "Hello World"

lvl_sBr :: GHC.Base.String
lvl_sBr = GHC.Show.showl lvl_sBs (GHC.Base.[] GHC.Base.Char)

lvl_sBq :: [GHC.Base.Char]
lvl_sBq = GHC.Base.: GHC.Base.Char GHC.Show.a77 lvl_sBr

a_sAA :: (GHC.Prim.State# GHC.Prim.RealWorld) → (#GHC.Prim.State# GHC.Prim.RealWorld, ()#)
Arity 1
Str: DmdType L
a_sAA
= λ(eta1_aum :: GHC.Prim.State# GHC.Prim.RealWorld) →
   case (GHC.IO.a25 GHC.Handle.stdout lvl_sBq eta1_aum)@(wild_aAn Dead Just A :: (#GHC.Prim.State# GHC.Prim.RealWorld, ()#)) of (#new_s_aAp Just L, a59_aAq Dead Just A#) → GHC.IO.$wa13 GHC.Handle.stdout '
' new_s_aAp

a_sAC :: (GHC.Prim.State# GHC.Prim.RealWorld) → (#GHC.Prim.State# GHC.Prim.RealWorld, ()#)
Arity 1
Str: DmdType L
a_sAC = GHC.TopHandler.a6 () (a_sAA ▶ (GHC.Prim.sym (GHC.IOBase.:CoIO ())))

Main.main_r72 :: GHC.IOBase.IO ()
[Exported]
Arity 1
Str: DmdType L
Main.main_r72 = a_sAA ▶ (GHC.Prim.sym (GHC.IOBase.:CoIO ()))

Main.my_foldr_r71 :: ∀t_a7l. ∀t_a7q. (t_a7q → t_a7l → t_a7l) → t_a7l → [t_a7q] → t_a7l
[Exported]
Arity 3
Str: DmdType LLS
Main.my_foldr_r71
= Λ(t_a7l :: GHC.Prim.*) →
   Λ(t_a7q :: GHC.Prim.*) →
    λ(c_a77 Just L :: t_a7q → t_a7l → t_a7l) →
     λ(n_a79 Just L :: t_a7l) →
      λ(eta_srZ :: [t_a7q]) →
           letrec
                 my_foldr'_sBn LoopBreaker :: [t_a7q] → t_a7l
                 Arity 1
                 Str: DmdType S
                 my_foldr'_sBn LoopBreaker
                 = λ(ds_drR :: [t_a7q]) →
                    case ds_drR@(wild_B1 Just A :: [t_a7q]) of
                        [GHC.Base.[]] → n_a79
                        [GHC.Base.: x_a7d Just L xs_a7f Just L] → c_a77 x_a7d (my_foldr'_sBn xs_a7f)
       in my_foldr'_sBn eta_srZ

Main.my_id_r6X :: ∀t_alK. t_alK → t_alK
[Exported]
Arity 1
Str: DmdType S
Main.my_id_r6X = Λ(t_alK :: GHC.Prim.*) → λ(x_a75 :: t_alK) → x_a75

lvl_sBt :: GHC.Integer.Integer
lvl_sBt = GHC.Integer.S# 1

Main.foo_r8 :: GHC.Integer.Integer
[Exported]
Str: DmdType
Main.foo_r8 = GHC.Integer.plusInteger lvl_sBt lvl_sBt

Main.bar_r73 :: GHC.Bool.Bool
[Exported]
Str: DmdType
Main.bar_r73
= case Main.foo_r8@(wild_atA Just A :: GHC.Integer.Integer) of
      [GHC.Integer.S# i_atC Just L]
      →
      case (GHC.Prim.># i_atC 2)@(wild_Xw Dead Just A :: GHC.Bool.Bool) of
          [GHC.Bool.False] → GHC.Bool.True
          [GHC.Bool.True] → GHC.Bool.False
      [GHC.Integer.J# s_atO Just L d_atP Just L]
      →
      case (GHC.Prim.cmpIntegerInt# s_atO d_atP 2)@(wild2_atV Just L :: GHC.Prim.Int#) of
          _
          →
          case (GHC.Prim.># wild2_atV 0)@(wild_Xw Dead Just A :: GHC.Bool.Bool) of
              [GHC.Bool.False] → GHC.Bool.True
              [GHC.Bool.True] → GHC.Bool.False

:Main.main :: GHC.IOBase.IO ()
[Exported]
Arity 1
Str: DmdType L
:Main.main = a_sAC ▶ (GHC.Prim.sym (GHC.IOBase.:CoIO ()))