Compare text

Find the difference between two text files

Real-time diff

Unified diff

Collapse lines

Highlight change

Syntax highlighting

Tools

Untitled diff

Created 6 years agoDiff never expires

==================== Tidy Core ====================

2018-03-31 08:12:10.538607 UTC

2018-03-31 08:12:01.1554222 UTC

Result size of Tidy Core

= {terms: 672, types: 587, coercions: 19, joins: 1/23}

= {terms: 678, types: 573, coercions: 19, joins: 1/23}

-- RHS size: {terms: 1, types: 0, coercions: 0, joins: 0/0}

Main.$trModule4 :: GHC.Prim.Addr#

[GblId,

Caf=NoCafRefs,

Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,

WorkFree=True, Expandable=True, Guidance=IF_ARGS [] 20 0}]

Main.$trModule4 = "main"#

-- RHS size: {terms: 2, types: 0, coercions: 0, joins: 0/0}

Main.$trModule3 :: GHC.Types.TrName

[GblId,

Caf=NoCafRefs,

Str=m1,

Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,

WorkFree=True, Expandable=True, Guidance=IF_ARGS [] 10 20}]

Main.$trModule3 = GHC.Types.TrNameS Main.$trModule4

-- RHS size: {terms: 1, types: 0, coercions: 0, joins: 0/0}

Main.$trModule2 :: GHC.Prim.Addr#

[GblId,

Caf=NoCafRefs,

Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,

WorkFree=True, Expandable=True, Guidance=IF_ARGS [] 20 0}]

Main.$trModule2 = "Main"#

-- RHS size: {terms: 2, types: 0, coercions: 0, joins: 0/0}

Main.$trModule1 :: GHC.Types.TrName

[GblId,

Caf=NoCafRefs,

Str=m1,

Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,

WorkFree=True, Expandable=True, Guidance=IF_ARGS [] 10 20}]

Main.$trModule1 = GHC.Types.TrNameS Main.$trModule2

-- RHS size: {terms: 3, types: 0, coercions: 0, joins: 0/0}

Main.$trModule :: GHC.Types.Module

[GblId,

Caf=NoCafRefs,

Str=m,

Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,

WorkFree=True, Expandable=True, Guidance=IF_ARGS [] 10 30}]

Main.$trModule = GHC.Types.Module Main.$trModule3 Main.$trModule1

Rec {

-- RHS size: {terms: 16, types: 20, coercions: 0, joins: 0/0}

poly_seqlist

:: forall a.

[a]

-> GHC.Prim.State# GHC.Prim.RealWorld

-> (# GHC.Prim.State# GHC.Prim.RealWorld, () #)

[GblId, Arity=2, Caf=NoCafRefs, Str=<S,1*U><S,U>, Unf=OtherCon []]

poly_seqlist

= \ (@ a)

(ds :: [a])

(eta :: GHC.Prim.State# GHC.Prim.RealWorld) ->

case ds of {

[] -> (# eta, GHC.Tuple.() #);

: x xs -> case x of { __DEFAULT -> poly_seqlist @ a xs eta }

}

end Rec }

-- RHS size: {terms: 1, types: 0, coercions: 0, joins: 0/0}

lvl :: Integer

[GblId, Caf=NoCafRefs, Unf=OtherCon []]

lvl = 0

-- RHS size: {terms: 406, types: 217, coercions: 0, joins: 1/23}

-- RHS size: {terms: 412, types: 203, coercions: 0, joins: 1/23}

$wrunbench

:: forall a b.

(Integer -> Integer -> a)

-> (Int -> Int -> b)

-> Integer

-> GHC.Prim.State# GHC.Prim.RealWorld

-> (# GHC.Prim.State# GHC.Prim.RealWorld, () #)

[GblId,

Arity=6,

Str=<L,C(C1(U))><L,C(C1(U))><S,U><S,U><S,U><S,U>,

Unf=OtherCon []]

$wrunbench

= \ (@ a)

(@ b)

(w :: Integer -> Integer -> a)

(w1 :: Int -> Int -> b)

(w2 :: Integer)

(w3 :: Integer)

(w4 :: Integer)

(w5 :: GHC.Prim.State# GHC.Prim.RealWorld) ->

case integer-gmp-1.0.1.0:GHC.Integer.Type.integerToInt w2 of wild

{ __DEFAULT ->

case integer-gmp-1.0.1.0:GHC.Integer.Type.integerToInt w3 of wild1

{ __DEFAULT ->

case integer-gmp-1.0.1.0:GHC.Integer.Type.integerToInt w4 of wild2

{ __DEFAULT ->

let {

x2 [Dmd=<S,U>] :: GHC.Prim.Int#

[LclId]

x2 = GHC.Prim.+# wild wild1 } in

let {

c [Dmd=<L,C(C1(U))>] :: Int -> [b] -> [b]

[LclId, Arity=2, Str=<L,U><L,U>, Unf=OtherCon []]

c = \ (ds :: Int) (ds1 [OS=OneShot] :: [b]) ->

let {

x1 [Dmd=<S,U>] :: GHC.Prim.Int#

[LclId]

x1 = GHC.Prim.+# wild wild1 } in

case GHC.Prim.>=# x1 wild of {

__DEFAULT ->

case GHC.Prim.># wild2 x1 of {

case GHC.Prim.tagToEnum# @ Bool (GHC.Prim.># wild2 x1) of single

{ __DEFAULT ->

case GHC.Prim.># wild2 wild of {

__DEFAULT ->

let {

delta [Dmd=<S,U>] :: GHC.Prim.Int#

[LclId]

delta = GHC.Prim.-# x1 wild } in

let {

y' :: GHC.Prim.Int#

[LclId]

y' = GHC.Prim.-# wild2 delta } in

GHC.Types.:

@ b

(w1 ds (GHC.Types.I# wild))

(let {

(case single of {

delta [Dmd=<S,U>] :: GHC.Prim.Int#

False ->

[LclId]

case GHC.Prim.<# wild y' of {

delta = GHC.Prim.-# x1 wild } in

__DEFAULT ->

let {

letrec {

y' [Dmd=<S,U>] :: GHC.Prim.Int#

go_dn [Occ=LoopBreaker] :: GHC.Prim.Int# -> [b]

[LclId]

[LclId, Arity=1, Str=<L,U>, Unf=OtherCon []]

y' = GHC.Prim.-# wild2 delta } in

go_dn

letrec {

= \ (x :: GHC.Prim.Int#) ->

go_dn [Occ=LoopBreaker] :: GHC.Prim.Int# -> [b]

GHC.Types.:

[LclId, Arity=1, Str=<S,U>, Unf=OtherCon []]

@ b

go_dn

(w1 ds (GHC.Types.I# x))

= \ (x :: GHC.Prim.Int#) ->

(case GHC.Prim.<# x y' of {

case GHC.Prim.<# x y' of {

__DEFAULT -> go_dn (GHC.Prim.+# x delta);

__DEFAULT ->

1# -> ds1

GHC.Types.:

}); } in

@ b (w1 ds (GHC.Types.I# x)) (go_dn (GHC.Prim.+# x delta));

go_dn (GHC.Prim.+# wild delta);

1# -> GHC.Types.: @ b (w1 ds (GHC.Types.I# x)) ds1

1# -> ds1

}; } in

};

go_dn x1);

True -> ds1

1# ->

});

case GHC.Prim.># wild2 wild of {

1# -> ds1

__DEFAULT -> GHC.Types.: @ b (w1 ds (GHC.Types.I# wild)) ds1;

}

1# -> ds1

}

};

1# ->

case GHC.Prim.<# wild2 x1 of {

case GHC.Prim.tagToEnum# @ Bool (GHC.Prim.<# wild2 x1) of single

{ __DEFAULT ->

case GHC.Prim.<# wild2 wild of {

__DEFAULT ->

let {

delta [Dmd=<S,U>] :: GHC.Prim.Int#

[LclId]

delta = GHC.Prim.-# x1 wild } in

let {

y' :: GHC.Prim.Int#

[LclId]

y' = GHC.Prim.-# wild2 delta } in

GHC.Types.:

@ b

(w1 ds (GHC.Types.I# wild))

(let {

(case single of {

delta [Dmd=<S,U>] :: GHC.Prim.Int#

False ->

[LclId]

case GHC.Prim.># wild y' of {

delta = GHC.Prim.-# x1 wild } in

__DEFAULT ->

let {

letrec {

y' [Dmd=<S,U>] :: GHC.Prim.Int#

go_up [Occ=LoopBreaker] :: GHC.Prim.Int# -> [b]

[LclId]

[LclId, Arity=1, Str=<L,U>, Unf=OtherCon []]

y' = GHC.Prim.-# wild2 delta } in

go_up

letrec {

= \ (x :: GHC.Prim.Int#) ->

go_up [Occ=LoopBreaker] :: GHC.Prim.Int# -> [b]

GHC.Types.:

[LclId, Arity=1, Str=<S,U>, Unf=OtherCon []]

@ b

go_up

(w1 ds (GHC.Types.I# x))

= \ (x :: GHC.Prim.Int#) ->

(case GHC.Prim.># x y' of {

case GHC.Prim.># x y' of {

__DEFAULT -> go_up (GHC.Prim.+# x delta);

__DEFAULT ->

1# -> ds1

GHC.Types.:

}); } in

@ b (w1 ds (GHC.Types.I# x)) (go_up (GHC.Prim.+# x delta));

go_up (GHC.Prim.+# wild delta);

1# -> GHC.Types.: @ b (w1 ds (GHC.Types.I# x)) ds1

1# -> ds1

}; } in

};

go_up x1);

True -> ds1

1# ->

});

case GHC.Prim.<# wild2 wild of {

1# -> ds1

__DEFAULT -> GHC.Types.: @ b (w1 ds (GHC.Types.I# wild)) ds1;

}

1# -> ds1

}

} } in

join {

$j [Dmd=<L,1*C1(C1(U(U,U)))>]

:: GHC.Prim.State# GHC.Prim.RealWorld

-> () -> (# GHC.Prim.State# GHC.Prim.RealWorld, () #)

[LclId[JoinId(2)], Arity=2, Str=<S,U><L,A>, Unf=OtherCon []]

$j (ipv [OS=OneShot] :: GHC.Prim.State# GHC.Prim.RealWorld)

_ [Occ=Dead, OS=OneShot]

= let {

delta [Dmd=<S,U>] :: Integer

[LclId]

delta

= integer-gmp-1.0.1.0:GHC.Integer.Type.minusInteger

(integer-gmp-1.0.1.0:GHC.Integer.Type.plusInteger w2 w3) w2 } in

let {

lvl5 [Dmd=<L,U(U)>] :: Int

[LclId]

lvl5

= case integer-gmp-1.0.1.0:GHC.Integer.Type.geInteger# delta lvl

of v

{ __DEFAULT ->

GHC.Types.I# v

} } in

let {

c1 [Dmd=<L,C(C1(U))>] :: Integer -> [a] -> [a]

[LclId, Arity=2, Str=<L,U><L,U>, Unf=OtherCon []]

= \ (ds :: Integer) (ds1 [OS=OneShot] :: [a]) ->

case lvl5 of { GHC.Types.I# v1 ->

case v1 of {

__DEFAULT ->

letrec {

go [Occ=LoopBreaker] :: Integer -> [a]

[LclId, Arity=1, Str=<S,U>, Unf=OtherCon []]

= \ (x :: Integer) ->

case integer-gmp-1.0.1.0:GHC.Integer.Type.ltInteger# x w4 of {

__DEFAULT ->

GHC.Types.:

@ a

(w ds x)

(go

(integer-gmp-1.0.1.0:GHC.Integer.Type.plusInteger

x delta));

1# -> ds1

}; } in

go w2;

1# ->

letrec {

go [Occ=LoopBreaker] :: Integer -> [a]

[LclId, Arity=1, Str=<S,U>, Unf=OtherCon []]

= \ (x :: Integer) ->

case integer-gmp-1.0.1.0:GHC.Integer.Type.gtInteger# x w4 of {

__DEFAULT ->

GHC.Types.:

@ a

(w ds x)

(go

(integer-gmp-1.0.1.0:GHC.Integer.Type.plusInteger

x delta));

1# -> ds1

}; } in

go w2

}

} } in

case integer-gmp-1.0.1.0:GHC.Integer.Type.geInteger# delta lvl of {

__DEFAULT ->

letrec {

go [Occ=LoopBreaker] :: Integer -> [a]

[LclId, Arity=1, Str=<S,U>, Unf=OtherCon []]

= \ (x :: Integer) ->

case integer-gmp-1.0.1.0:GHC.Integer.Type.ltInteger# x w4 of {

__DEFAULT ->

x (go (integer-gmp-1.0.1.0:GHC.Integer.Type.plusInteger x delta));

1# -> GHC.Types.[] @ a

}; } in

case poly_seqlist @ a (go w2) ipv of { (# ipv2, ipv3 #) ->

(# ipv2, GHC.Tuple.() #)

};

1# ->

letrec {

go [Occ=LoopBreaker] :: Integer -> [a]

[LclId, Arity=1, Str=<S,U>, Unf=OtherCon []]

= \ (x :: Integer) ->

case integer-gmp-1.0.1.0:GHC.Integer.Type.gtInteger# x w4 of {

__DEFAULT ->

x (go (integer-gmp-1.0.1.0:GHC.Integer.Type.plusInteger x delta));

1# -> GHC.Types.[] @ a

}; } in

case poly_seqlist @ a (go w2) ipv of { (# ipv2, ipv3 #) ->

(# ipv2, GHC.Tuple.() #)

}

} } in

case GHC.Prim.>=# x2 wild of {

__DEFAULT ->

case GHC.Prim.># wild2 x2 of {

case GHC.Prim.tagToEnum# @ Bool (GHC.Prim.># wild2 x2) of single

{ __DEFAULT ->

case GHC.Prim.># wild2 wild of {

__DEFAULT ->

let {

delta [Dmd=<S,U>] :: GHC.Prim.Int#

[LclId]

delta = GHC.Prim.-# x2 wild } in

let {

y' :: GHC.Prim.Int#

[LclId]

y' = GHC.Prim.-# wild2 delta } in

case poly_seqlist

@ b

(c (GHC.Types.I# wild)

(let {

(case single of {

delta [Dmd=<S,U>] :: GHC.Prim.Int#

False ->

[LclId]

case GHC.Prim.<# wild y' of {

delta = GHC.Prim.-# x2 wild } in

__DEFAULT ->

let {

letrec {

y' [Dmd=<S,U>] :: GHC.Prim.Int#

go_dn [Occ=LoopBreaker] :: GHC.Prim.Int# -> [b]

[LclId]

[LclId, Arity=1, Str=<L,U>, Unf=OtherCon []]

y' = GHC.Prim.-# wild2 delta } in

go_dn

letrec {

= \ (x :: GHC.Prim.Int#) ->

go_dn [Occ=LoopBreaker] :: GHC.Prim.Int# -> [b]

c (GHC.Types.I# x)

[LclId, Arity=1, Str=<S,U>, Unf=OtherCon []]

(case GHC.Prim.<# x y' of {

go_dn

__DEFAULT -> go_dn (GHC.Prim.+# x delta);

= \ (x :: GHC.Prim.Int#) ->

1# -> GHC.Types.[] @ b

case GHC.Prim.<# x y' of {

}); } in

__DEFAULT -> c (GHC.Types.I# x) (go_dn (GHC.Prim.+# x delta));

go_dn (GHC.Prim.+# wild delta);

1# -> c (GHC.Types.I# x) (GHC.Types.[] @ b)

1# -> GHC.Types.[] @ b

}; } in

};

go_dn x2))

True -> GHC.Types.[] @ b

}))

{ (# ipv, ipv1 #) ->

jump $j ipv ipv1

};

1# ->

1# -> jump $j w5 GHC.Tuple.()

case GHC.Prim.># wild2 wild of {

}

__DEFAULT ->

case poly_seqlist @ b (c (GHC.Types.I# wild) (GHC.Types.[] @ b)) w5

{ (# ipv, ipv1 #) ->

jump $j ipv ipv1

};

1# -> jump $j w5 GHC.Tuple.()

}

};

1# ->

case GHC.Prim.<# wild2 x2 of {

case GHC.Prim.tagToEnum# @ Bool (GHC.Prim.<# wild2 x2) of single

{ __DEFAULT ->

case GHC.Prim.<# wild2 wild of {

__DEFAULT ->

let {

delta [Dmd=<S,U>] :: GHC.Prim.Int#

[LclId]

delta = GHC.Prim.-# x2 wild } in

let {

y' :: GHC.Prim.Int#

[LclId]

y' = GHC.Prim.-# wild2 delta } in

case poly_seqlist

@ b

(c (GHC.Types.I# wild)

(let {

(case single of {

delta [Dmd=<S,U>] :: GHC.Prim.Int#

False ->

[LclId]

case GHC.Prim.># wild y' of {

delta = GHC.Prim.-# x2 wild } in

__DEFAULT ->

let {

letrec {

y' [Dmd=<S,U>] :: GHC.Prim.Int#

go_up [Occ=LoopBreaker] :: GHC.Prim.Int# -> [b]

[LclId]

[LclId, Arity=1, Str=<L,U>, Unf=OtherCon []]

y' = GHC.Prim.-# wild2 delta } in

go_up

letrec {

= \ (x :: GHC.Prim.Int#) ->

go_up [Occ=LoopBreaker] :: GHC.Prim.Int# -> [b]

c (GHC.Types.I# x)

[LclId, Arity=1, Str=<S,U>, Unf=OtherCon []]

(case GHC.Prim.># x y' of {

go_up

__DEFAULT -> go_up (GHC.Prim.+# x delta);

= \ (x :: GHC.Prim.Int#) ->

1# -> GHC.Types.[] @ b

case GHC.Prim.># x y' of {

}); } in

__DEFAULT -> c (GHC.Types.I# x) (go_up (GHC.Prim.+# x delta));

go_up (GHC.Prim.+# wild delta);

1# -> c (GHC.Types.I# x) (GHC.Types.[] @ b)

1# -> GHC.Types.[] @ b

}; } in

};

go_up x2))

True -> GHC.Types.[] @ b

}))

{ (# ipv, ipv1 #) ->

jump $j ipv ipv1

};

1# ->

1# -> jump $j w5 GHC.Tuple.()

case GHC.Prim.<# wild2 wild of {

}

__DEFAULT ->

case poly_seqlist @ b (c (GHC.Types.I# wild) (GHC.Types.[] @ b)) w5

{ (# ipv, ipv1 #) ->

jump $j ipv ipv1

};

1# -> jump $j w5 GHC.Tuple.()

}

-- RHS size: {terms: 1, types: 0, coercions: 0, joins: 0/0}

lvl1 :: GHC.Prim.Addr#

[GblId, Caf=NoCafRefs, Unf=OtherCon []]

lvl1 = "Pattern match failure in do expression at Main.hs:9:3-12"#

-- RHS size: {terms: 2, types: 0, coercions: 0, joins: 0/0}

lvl2 :: [Char]

[GblId]

lvl2 = GHC.CString.unpackCString# lvl1

-- RHS size: {terms: 5, types: 9, coercions: 10, joins: 0/0}

$wfail

:: GHC.Prim.State# GHC.Prim.RealWorld

-> (# GHC.Prim.State# GHC.Prim.RealWorld, () #)

[GblId, Arity=1, Str=<S,U>, Unf=OtherCon []]

$wfail

= \ (w :: GHC.Prim.State# GHC.Prim.RealWorld) ->

((GHC.Magic.noinline

@ (forall a. [Char] -> IO a)

(GHC.IO.failIO1

`cast` (forall (a :: <*>_N).

<String>_R ->_R Sym (GHC.Types.N:IO[0] <a>_R)

:: (forall a.

String

-> GHC.Prim.State# GHC.Prim.RealWorld

-> (# GHC.Prim.State# GHC.Prim.RealWorld, a #) :: *)

~R# (forall a. String -> IO a :: *)))

@ ()

lvl2)

`cast` (GHC.Types.N:IO[0] <()>_R

:: (IO () :: *)

~R# (GHC.Prim.State# GHC.Prim.RealWorld

-> (# GHC.Prim.State# GHC.Prim.RealWorld, () #) :: *)))

-- RHS size: {terms: 2, types: 2, coercions: 0, joins: 0/0}

lvl3 :: Integer

[GblId, Str=x]

lvl3

= errorWithoutStackTrace

@ 'GHC.Types.LiftedRep @ Integer Text.Read.readEither5

-- RHS size: {terms: 2, types: 2, coercions: 0, joins: 0/0}

lvl4 :: Integer

[GblId, Str=x]

lvl4

= errorWithoutStackTrace

@ 'GHC.Types.LiftedRep @ Integer Text.Read.readEither2

-- RHS size: {terms: 207, types: 254, coercions: 0, joins: 0/0}

Main.main1

:: GHC.Prim.State# GHC.Prim.RealWorld

-> (# GHC.Prim.State# GHC.Prim.RealWorld, () #)

[GblId, Arity=1, Str=<S,U>, Unf=OtherCon []]

Main.main1

= \ (s :: GHC.Prim.State# GHC.Prim.RealWorld) ->

case System.Environment.getArgs1 s of { (# ipv, ipv1 #) ->

case ipv1 of {

[] -> $wfail ipv;

: _1 ds ->

case ds of {

[] -> $wfail ipv;

: _2 ds2 ->

case ds2 of {

[] -> $wfail ipv;

: _3 ds3 ->

case ds3 of {

[] ->

case Text.Read.readEither8

@ Integer

(Text.ParserCombinators.ReadP.run

@ Integer

(GHC.Read.$fReadInteger_$sreadNumber

GHC.Read.$fReadInteger2

Text.ParserCombinators.ReadPrec.minPrec

@ Integer

(Text.Read.readEither7 @ Integer))

_1)

of {

[] -> case lvl3 of wild5 { };

: x ds4 ->

case ds4 of {

[] ->

case Text.Read.readEither8

@ Integer

(Text.ParserCombinators.ReadP.run

@ Integer

(GHC.Read.$fReadInteger_$sreadNumber

GHC.Read.$fReadInteger2

Text.ParserCombinators.ReadPrec.minPrec

@ Integer

(Text.Read.readEither7 @ Integer))

_2)

of {

[] -> case lvl3 of wild7 { };

: x1 ds5 ->

case ds5 of {

[] ->

case Text.Read.readEither8

@ Integer

(Text.ParserCombinators.ReadP.run

@ Integer

(GHC.Read.$fReadInteger_$sreadNumber

GHC.Read.$fReadInteger2

Text.ParserCombinators.ReadPrec.minPrec

@ Integer

(Text.Read.readEither7 @ Integer))

_3)

of {

[] -> case lvl3 of wild9 { };

: x2 ds6 ->

case ds6 of {

[] ->

case $wrunbench

@ Integer

@ Int

integer-gmp-1.0.1.0:GHC.Integer.Type.plusInteger

GHC.Num.$fNumInt_$c+

ipv

{ (# ipv2, ipv3 #) ->

case $wrunbench

@ Integer

@ Int

integer-gmp-1.0.1.0:GHC.Integer.Type.minusInteger

GHC.Num.$fNumInt_$c-

ipv2

{ (# ipv4, ipv5 #) ->

case $wrunbench

@ Integer

@ Int

integer-gmp-1.0.1.0:GHC.Integer.Type.timesInteger

GHC.Num.$fNumInt_$c*

ipv4

{ (# ipv6, ipv7 #) ->

case $wrunbench

@ Integer

@ Int

GHC.Real.$fIntegralInteger_$cdiv

GHC.Real.$fIntegralInt_$cdiv

ipv6

{ (# ipv8, ipv9 #) ->

case $wrunbench

@ Integer

@ Int

GHC.Real.$fIntegralInteger_$cmod

GHC.Real.$fIntegralInt_$cmod

ipv8

{ (# ipv10, ipv11 #) ->

case $wrunbench

@ Integer

@ Int

GHC.Real.$fIntegralInteger_$cquot

GHC.Real.$fIntegralInt_$cquot

ipv10

{ (# ipv12, ipv13 #) ->

case $wrunbench

@ Integer

@ Int

GHC.Real.$fIntegralInteger_$crem

GHC.Real.$fIntegralInt_$crem

ipv12

{ (# ipv14, ipv15 #) ->

case $wrunbench

@ Integer

@ Int

integer-gmp-1.0.1.0:GHC.Integer.Type.gcdInteger

GHC.Real.gcdInt'

ipv14

{ (# ipv1

Saved diffs

Original text

Open file


==================== Tidy Core ====================
2018-03-31 08:12:10.538607 UTC

Result size of Tidy Core
  = {terms: 672, types: 587, coercions: 19, joins: 1/23}

-- RHS size: {terms: 1, types: 0, coercions: 0, joins: 0/0}
Main.$trModule4 :: GHC.Prim.Addr#
[GblId,
 Caf=NoCafRefs,
 Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
         WorkFree=True, Expandable=True, Guidance=IF_ARGS [] 20 0}]
Main.$trModule4 = "main"#

-- RHS size: {terms: 2, types: 0, coercions: 0, joins: 0/0}
Main.$trModule3 :: GHC.Types.TrName
[GblId,
 Caf=NoCafRefs,
 Str=m1,
 Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
         WorkFree=True, Expandable=True, Guidance=IF_ARGS [] 10 20}]
Main.$trModule3 = GHC.Types.TrNameS Main.$trModule4

-- RHS size: {terms: 1, types: 0, coercions: 0, joins: 0/0}
Main.$trModule2 :: GHC.Prim.Addr#
[GblId,
 Caf=NoCafRefs,
 Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
         WorkFree=True, Expandable=True, Guidance=IF_ARGS [] 20 0}]
Main.$trModule2 = "Main"#

-- RHS size: {terms: 2, types: 0, coercions: 0, joins: 0/0}
Main.$trModule1 :: GHC.Types.TrName
[GblId,
 Caf=NoCafRefs,
 Str=m1,
 Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
         WorkFree=True, Expandable=True, Guidance=IF_ARGS [] 10 20}]
Main.$trModule1 = GHC.Types.TrNameS Main.$trModule2

-- RHS size: {terms: 3, types: 0, coercions: 0, joins: 0/0}
Main.$trModule :: GHC.Types.Module
[GblId,
 Caf=NoCafRefs,
 Str=m,
 Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
         WorkFree=True, Expandable=True, Guidance=IF_ARGS [] 10 30}]
Main.$trModule = GHC.Types.Module Main.$trModule3 Main.$trModule1

Rec {
-- RHS size: {terms: 16, types: 20, coercions: 0, joins: 0/0}
poly_seqlist
  :: forall a.
     [a]
     -> GHC.Prim.State# GHC.Prim.RealWorld
     -> (# GHC.Prim.State# GHC.Prim.RealWorld, () #)
[GblId, Arity=2, Caf=NoCafRefs, Str=<S,1*U><S,U>, Unf=OtherCon []]
poly_seqlist
  = \ (@ a)
      (ds :: [a])
      (eta :: GHC.Prim.State# GHC.Prim.RealWorld) ->
      case ds of {
        [] -> (# eta, GHC.Tuple.() #);
        : x xs -> case x of { __DEFAULT -> poly_seqlist @ a xs eta }
      }
end Rec }

-- RHS size: {terms: 1, types: 0, coercions: 0, joins: 0/0}
lvl :: Integer
[GblId, Caf=NoCafRefs, Unf=OtherCon []]
lvl = 0

-- RHS size: {terms: 406, types: 217, coercions: 0, joins: 1/23}
$wrunbench
  :: forall a b.
     (Integer -> Integer -> a)
     -> (Int -> Int -> b)
     -> Integer
     -> Integer
     -> Integer
     -> GHC.Prim.State# GHC.Prim.RealWorld
     -> (# GHC.Prim.State# GHC.Prim.RealWorld, () #)
[GblId,
 Arity=6,
 Str=<L,C(C1(U))><L,C(C1(U))><S,U><S,U><S,U><S,U>,
 Unf=OtherCon []]
$wrunbench
  = \ (@ a)
      (@ b)
      (w :: Integer -> Integer -> a)
      (w1 :: Int -> Int -> b)
      (w2 :: Integer)
      (w3 :: Integer)
      (w4 :: Integer)
      (w5 :: GHC.Prim.State# GHC.Prim.RealWorld) ->
      case integer-gmp-1.0.1.0:GHC.Integer.Type.integerToInt w2 of wild
      { __DEFAULT ->
      case integer-gmp-1.0.1.0:GHC.Integer.Type.integerToInt w3 of wild1
      { __DEFAULT ->
      case integer-gmp-1.0.1.0:GHC.Integer.Type.integerToInt w4 of wild2
      { __DEFAULT ->
      let {
        x2 [Dmd=<S,U>] :: GHC.Prim.Int#
        [LclId]
        x2 = GHC.Prim.+# wild wild1 } in
      let {
        c [Dmd=<L,C(C1(U))>] :: Int -> [b] -> [b]
        [LclId, Arity=2, Str=<L,U><L,U>, Unf=OtherCon []]
        c = \ (ds :: Int) (ds1 [OS=OneShot] :: [b]) ->
              let {
                x1 [Dmd=<S,U>] :: GHC.Prim.Int#
                [LclId]
                x1 = GHC.Prim.+# wild wild1 } in
              case GHC.Prim.>=# x1 wild of {
                __DEFAULT ->
                  case GHC.Prim.># wild2 x1 of {
                    __DEFAULT ->
                      GHC.Types.:
                        @ b
                        (w1 ds (GHC.Types.I# wild))
                        (let {
                           delta [Dmd=<S,U>] :: GHC.Prim.Int#
                           [LclId]
                           delta = GHC.Prim.-# x1 wild } in
                         let {
                           y' [Dmd=<S,U>] :: GHC.Prim.Int#
                           [LclId]
                           y' = GHC.Prim.-# wild2 delta } in
                         letrec {
                           go_dn [Occ=LoopBreaker] :: GHC.Prim.Int# -> [b]
                           [LclId, Arity=1, Str=<S,U>, Unf=OtherCon []]
                           go_dn
                             = \ (x :: GHC.Prim.Int#) ->
                                 case GHC.Prim.<# x y' of {
                                   __DEFAULT ->
                                     GHC.Types.:
                                       @ b (w1 ds (GHC.Types.I# x)) (go_dn (GHC.Prim.+# x delta));
                                   1# -> GHC.Types.: @ b (w1 ds (GHC.Types.I# x)) ds1
                                 }; } in
                         go_dn x1);
                    1# ->
                      case GHC.Prim.># wild2 wild of {
                        __DEFAULT -> GHC.Types.: @ b (w1 ds (GHC.Types.I# wild)) ds1;
                        1# -> ds1
                      }
                  };
                1# ->
                  case GHC.Prim.<# wild2 x1 of {
                    __DEFAULT ->
                      GHC.Types.:
                        @ b
                        (w1 ds (GHC.Types.I# wild))
                        (let {
                           delta [Dmd=<S,U>] :: GHC.Prim.Int#
                           [LclId]
                           delta = GHC.Prim.-# x1 wild } in
                         let {
                           y' [Dmd=<S,U>] :: GHC.Prim.Int#
                           [LclId]
                           y' = GHC.Prim.-# wild2 delta } in
                         letrec {
                           go_up [Occ=LoopBreaker] :: GHC.Prim.Int# -> [b]
                           [LclId, Arity=1, Str=<S,U>, Unf=OtherCon []]
                           go_up
                             = \ (x :: GHC.Prim.Int#) ->
                                 case GHC.Prim.># x y' of {
                                   __DEFAULT ->
                                     GHC.Types.:
                                       @ b (w1 ds (GHC.Types.I# x)) (go_up (GHC.Prim.+# x delta));
                                   1# -> GHC.Types.: @ b (w1 ds (GHC.Types.I# x)) ds1
                                 }; } in
                         go_up x1);
                    1# ->
                      case GHC.Prim.<# wild2 wild of {
                        __DEFAULT -> GHC.Types.: @ b (w1 ds (GHC.Types.I# wild)) ds1;
                        1# -> ds1
                      }
                  }
              } } in
      join {
        $j [Dmd=<L,1*C1(C1(U(U,U)))>]
          :: GHC.Prim.State# GHC.Prim.RealWorld
             -> () -> (# GHC.Prim.State# GHC.Prim.RealWorld, () #)
        [LclId[JoinId(2)], Arity=2, Str=<S,U><L,A>, Unf=OtherCon []]
        $j (ipv [OS=OneShot] :: GHC.Prim.State# GHC.Prim.RealWorld)
           _ [Occ=Dead, OS=OneShot]
          = let {
              delta [Dmd=<S,U>] :: Integer
              [LclId]
              delta
                = integer-gmp-1.0.1.0:GHC.Integer.Type.minusInteger
                    (integer-gmp-1.0.1.0:GHC.Integer.Type.plusInteger w2 w3) w2 } in
            let {
              lvl5 [Dmd=<L,U(U)>] :: Int
              [LclId]
              lvl5
                = case integer-gmp-1.0.1.0:GHC.Integer.Type.geInteger# delta lvl
                  of v
                  { __DEFAULT ->
                  GHC.Types.I# v
                  } } in
            let {
              c1 [Dmd=<L,C(C1(U))>] :: Integer -> [a] -> [a]
              [LclId, Arity=2, Str=<L,U><L,U>, Unf=OtherCon []]
              c1
                = \ (ds :: Integer) (ds1 [OS=OneShot] :: [a]) ->
                    case lvl5 of { GHC.Types.I# v1 ->
                    case v1 of {
                      __DEFAULT ->
                        letrec {
                          go [Occ=LoopBreaker] :: Integer -> [a]
                          [LclId, Arity=1, Str=<S,U>, Unf=OtherCon []]
                          go
                            = \ (x :: Integer) ->
                                case integer-gmp-1.0.1.0:GHC.Integer.Type.ltInteger# x w4 of {
                                  __DEFAULT ->
                                    GHC.Types.:
                                      @ a
                                      (w ds x)
                                      (go
                                         (integer-gmp-1.0.1.0:GHC.Integer.Type.plusInteger
                                            x delta));
                                  1# -> ds1
                                }; } in
                        go w2;
                      1# ->
                        letrec {
                          go [Occ=LoopBreaker] :: Integer -> [a]
                          [LclId, Arity=1, Str=<S,U>, Unf=OtherCon []]
                          go
                            = \ (x :: Integer) ->
                                case integer-gmp-1.0.1.0:GHC.Integer.Type.gtInteger# x w4 of {
                                  __DEFAULT ->
                                    GHC.Types.:
                                      @ a
                                      (w ds x)
                                      (go
                                         (integer-gmp-1.0.1.0:GHC.Integer.Type.plusInteger
                                            x delta));
                                  1# -> ds1
                                }; } in
                        go w2
                    }
                    } } in
            case integer-gmp-1.0.1.0:GHC.Integer.Type.geInteger# delta lvl of {
              __DEFAULT ->
                letrec {
                  go [Occ=LoopBreaker] :: Integer -> [a]
                  [LclId, Arity=1, Str=<S,U>, Unf=OtherCon []]
                  go
                    = \ (x :: Integer) ->
                        case integer-gmp-1.0.1.0:GHC.Integer.Type.ltInteger# x w4 of {
                          __DEFAULT ->
                            c1
                              x (go (integer-gmp-1.0.1.0:GHC.Integer.Type.plusInteger x delta));
                          1# -> GHC.Types.[] @ a
                        }; } in
                case poly_seqlist @ a (go w2) ipv of { (# ipv2, ipv3 #) ->
                (# ipv2, GHC.Tuple.() #)
                };
              1# ->
                letrec {
                  go [Occ=LoopBreaker] :: Integer -> [a]
                  [LclId, Arity=1, Str=<S,U>, Unf=OtherCon []]
                  go
                    = \ (x :: Integer) ->
                        case integer-gmp-1.0.1.0:GHC.Integer.Type.gtInteger# x w4 of {
                          __DEFAULT ->
                            c1
                              x (go (integer-gmp-1.0.1.0:GHC.Integer.Type.plusInteger x delta));
                          1# -> GHC.Types.[] @ a
                        }; } in
                case poly_seqlist @ a (go w2) ipv of { (# ipv2, ipv3 #) ->
                (# ipv2, GHC.Tuple.() #)
                }
            } } in
      case GHC.Prim.>=# x2 wild of {
        __DEFAULT ->
          case GHC.Prim.># wild2 x2 of {
            __DEFAULT ->
              case poly_seqlist
                     @ b
                     (c (GHC.Types.I# wild)
                        (let {
                           delta [Dmd=<S,U>] :: GHC.Prim.Int#
                           [LclId]
                           delta = GHC.Prim.-# x2 wild } in
                         let {
                           y' [Dmd=<S,U>] :: GHC.Prim.Int#
                           [LclId]
                           y' = GHC.Prim.-# wild2 delta } in
                         letrec {
                           go_dn [Occ=LoopBreaker] :: GHC.Prim.Int# -> [b]
                           [LclId, Arity=1, Str=<S,U>, Unf=OtherCon []]
                           go_dn
                             = \ (x :: GHC.Prim.Int#) ->
                                 case GHC.Prim.<# x y' of {
                                   __DEFAULT -> c (GHC.Types.I# x) (go_dn (GHC.Prim.+# x delta));
                                   1# -> c (GHC.Types.I# x) (GHC.Types.[] @ b)
                                 }; } in
                         go_dn x2))
                     w5
              of
              { (# ipv, ipv1 #) ->
              jump $j ipv ipv1
              };
            1# ->
              case GHC.Prim.># wild2 wild of {
                __DEFAULT ->
                  case poly_seqlist @ b (c (GHC.Types.I# wild) (GHC.Types.[] @ b)) w5
                  of
                  { (# ipv, ipv1 #) ->
                  jump $j ipv ipv1
                  };
                1# -> jump $j w5 GHC.Tuple.()
              }
          };
        1# ->
          case GHC.Prim.<# wild2 x2 of {
            __DEFAULT ->
              case poly_seqlist
                     @ b
                     (c (GHC.Types.I# wild)
                        (let {
                           delta [Dmd=<S,U>] :: GHC.Prim.Int#
                           [LclId]
                           delta = GHC.Prim.-# x2 wild } in
                         let {
                           y' [Dmd=<S,U>] :: GHC.Prim.Int#
                           [LclId]
                           y' = GHC.Prim.-# wild2 delta } in
                         letrec {
                           go_up [Occ=LoopBreaker] :: GHC.Prim.Int# -> [b]
                           [LclId, Arity=1, Str=<S,U>, Unf=OtherCon []]
                           go_up
                             = \ (x :: GHC.Prim.Int#) ->
                                 case GHC.Prim.># x y' of {
                                   __DEFAULT -> c (GHC.Types.I# x) (go_up (GHC.Prim.+# x delta));
                                   1# -> c (GHC.Types.I# x) (GHC.Types.[] @ b)
                                 }; } in
                         go_up x2))
                     w5
              of
              { (# ipv, ipv1 #) ->
              jump $j ipv ipv1
              };
            1# ->
              case GHC.Prim.<# wild2 wild of {
                __DEFAULT ->
                  case poly_seqlist @ b (c (GHC.Types.I# wild) (GHC.Types.[] @ b)) w5
                  of
                  { (# ipv, ipv1 #) ->
                  jump $j ipv ipv1
                  };
                1# -> jump $j w5 GHC.Tuple.()
              }
          }
      }
      }
      }
      }

-- RHS size: {terms: 1, types: 0, coercions: 0, joins: 0/0}
lvl1 :: GHC.Prim.Addr#
[GblId, Caf=NoCafRefs, Unf=OtherCon []]
lvl1 = "Pattern match failure in do expression at Main.hs:9:3-12"#

-- RHS size: {terms: 2, types: 0, coercions: 0, joins: 0/0}
lvl2 :: [Char]
[GblId]
lvl2 = GHC.CString.unpackCString# lvl1

-- RHS size: {terms: 5, types: 9, coercions: 10, joins: 0/0}
$wfail
  :: GHC.Prim.State# GHC.Prim.RealWorld
     -> (# GHC.Prim.State# GHC.Prim.RealWorld, () #)
[GblId, Arity=1, Str=<S,U>, Unf=OtherCon []]
$wfail
  = \ (w :: GHC.Prim.State# GHC.Prim.RealWorld) ->
      ((GHC.Magic.noinline
          @ (forall a. [Char] -> IO a)
          (GHC.IO.failIO1
           `cast` (forall (a :: <*>_N).
                   <String>_R ->_R Sym (GHC.Types.N:IO[0] <a>_R)
                   :: (forall a.
                       String
                       -> GHC.Prim.State# GHC.Prim.RealWorld
                       -> (# GHC.Prim.State# GHC.Prim.RealWorld, a #) :: *)
                      ~R# (forall a. String -> IO a :: *)))
          @ ()
          lvl2)
       `cast` (GHC.Types.N:IO[0] <()>_R
               :: (IO () :: *)
                  ~R# (GHC.Prim.State# GHC.Prim.RealWorld
                       -> (# GHC.Prim.State# GHC.Prim.RealWorld, () #) :: *)))
        w

-- RHS size: {terms: 2, types: 2, coercions: 0, joins: 0/0}
lvl3 :: Integer
[GblId, Str=x]
lvl3
  = errorWithoutStackTrace
      @ 'GHC.Types.LiftedRep @ Integer Text.Read.readEither5

-- RHS size: {terms: 2, types: 2, coercions: 0, joins: 0/0}
lvl4 :: Integer
[GblId, Str=x]
lvl4
  = errorWithoutStackTrace
      @ 'GHC.Types.LiftedRep @ Integer Text.Read.readEither2

-- RHS size: {terms: 207, types: 254, coercions: 0, joins: 0/0}
Main.main1
  :: GHC.Prim.State# GHC.Prim.RealWorld
     -> (# GHC.Prim.State# GHC.Prim.RealWorld, () #)
[GblId, Arity=1, Str=<S,U>, Unf=OtherCon []]
Main.main1
  = \ (s :: GHC.Prim.State# GHC.Prim.RealWorld) ->
      case System.Environment.getArgs1 s of { (# ipv, ipv1 #) ->
      case ipv1 of {
        [] -> $wfail ipv;
        : _1 ds ->
          case ds of {
            [] -> $wfail ipv;
            : _2 ds2 ->
              case ds2 of {
                [] -> $wfail ipv;
                : _3 ds3 ->
                  case ds3 of {
                    [] ->
                      case Text.Read.readEither8
                             @ Integer
                             (Text.ParserCombinators.ReadP.run
                                @ Integer
                                (GHC.Read.$fReadInteger_$sreadNumber
                                   GHC.Read.$fReadInteger2
                                   Text.ParserCombinators.ReadPrec.minPrec
                                   @ Integer
                                   (Text.Read.readEither7 @ Integer))
                                _1)
                      of {
                        [] -> case lvl3 of wild5 { };
                        : x ds4 ->
                          case ds4 of {
                            [] ->
                              case Text.Read.readEither8
                                     @ Integer
                                     (Text.ParserCombinators.ReadP.run
                                        @ Integer
                                        (GHC.Read.$fReadInteger_$sreadNumber
                                           GHC.Read.$fReadInteger2
                                           Text.ParserCombinators.ReadPrec.minPrec
                                           @ Integer
                                           (Text.Read.readEither7 @ Integer))
                                        _2)
                              of {
                                [] -> case lvl3 of wild7 { };
                                : x1 ds5 ->
                                  case ds5 of {
                                    [] ->
                                      case Text.Read.readEither8
                                             @ Integer
                                             (Text.ParserCombinators.ReadP.run
                                                @ Integer
                                                (GHC.Read.$fReadInteger_$sreadNumber
                                                   GHC.Read.$fReadInteger2
                                                   Text.ParserCombinators.ReadPrec.minPrec
                                                   @ Integer
                                                   (Text.Read.readEither7 @ Integer))
                                                _3)
                                      of {
                                        [] -> case lvl3 of wild9 { };
                                        : x2 ds6 ->
                                          case ds6 of {
                                            [] ->
                                              case $wrunbench
                                                     @ Integer
                                                     @ Int
                                                     integer-gmp-1.0.1.0:GHC.Integer.Type.plusInteger
                                                     GHC.Num.$fNumInt_$c+
                                                     x
                                                     x1
                                                     x2
                                                     ipv
                                              of
                                              { (# ipv2, ipv3 #) ->
                                              case $wrunbench
                                                     @ Integer
                                                     @ Int
                                                     integer-gmp-1.0.1.0:GHC.Integer.Type.minusInteger
                                                     GHC.Num.$fNumInt_$c-
                                                     x
                                                     x1
                                                     x2
                                                     ipv2
                                              of
                                              { (# ipv4, ipv5 #) ->
                                              case $wrunbench
                                                     @ Integer
                                                     @ Int
                                                     integer-gmp-1.0.1.0:GHC.Integer.Type.timesInteger
                                                     GHC.Num.$fNumInt_$c*
                                                     x
                                                     x1
                                                     x2
                                                     ipv4
                                              of
                                              { (# ipv6, ipv7 #) ->
                                              case $wrunbench
                                                     @ Integer
                                                     @ Int
                                                     GHC.Real.$fIntegralInteger_$cdiv
                                                     GHC.Real.$fIntegralInt_$cdiv
                                                     x
                                                     x1
                                                     x2
                                                     ipv6
                                              of
                                              { (# ipv8, ipv9 #) ->
                                              case $wrunbench
                                                     @ Integer
                                                     @ Int
                                                     GHC.Real.$fIntegralInteger_$cmod
                                                     GHC.Real.$fIntegralInt_$cmod
                                                     x
                                                     x1
                                                     x2
                                                     ipv8
                                              of
                                              { (# ipv10, ipv11 #) ->
                                              case $wrunbench
                                                     @ Integer
                                                     @ Int
                                                     GHC.Real.$fIntegralInteger_$cquot
                                                     GHC.Real.$fIntegralInt_$cquot
                                                     x
                                                     x1
                                                     x2
                                                     ipv10
                                              of
                                              { (# ipv12, ipv13 #) ->
                                              case $wrunbench
                                                     @ Integer
                                                     @ Int
                                                     GHC.Real.$fIntegralInteger_$crem
                                                     GHC.Real.$fIntegralInt_$crem
                                                     x
                                                     x1
                                                     x2
                                                     ipv12
                                              of
                                              { (# ipv14, ipv15 #) ->
                                              case $wrunbench
                                                     @ Integer
                                                     @ Int
                                                     integer-gmp-1.0.1.0:GHC.Integer.Type.gcdInteger
                                                     GHC.Real.gcdInt'
                                                     x
                                                     x1
                                                     x2
                                                     ipv14
                                              of
                                              { (# ipv16, ipv17 #) ->
                                              case $wrunbench
                                                     @ Integer
                                                     @ Int
                                                     integer-gmp-1.0.1.0:GHC.Integer.Type.lcmInteger
                                                     GHC.Real.lcm_$slcm1
                                                     x
                                                     x1
                                                     x2
                                                     ipv16
                                              of
                                              { (# ipv18, ipv19 #) ->
                                              case $wrunbench
                                                     @ Bool
                                                     @ Bool
                                                     integer-gmp-1.0.1.0:GHC.Integer.Type.eqInteger
                                                     GHC.Classes.eqInt
                                                     x
                                                     x1
                                                     x2
                                                     ipv18
                                              of
                                              { (# ipv20, ipv21 #) ->
                                              case $wrunbench
                                                     @ Bool
                                                     @ Bool
                                                     integer-gmp-1.0.1.0:GHC.Integer.Type.ltInteger
                                                     GHC.Classes.ltInt
                                                     x
                                                     x1
                                                     x2
                                                     ipv20
                                              of
                                              { (# ipv22, ipv23 #) ->
                                              case $wrunbench
                                                     @ Bool
                                                     @ Bool
                                                     integer-gmp-1.0.1.0:GHC.Integer.Type.leInteger
                                                     GHC.Classes.leInt
                                                     x
                                                     x1
                                                     x2
                                                     ipv22
                                              of
                                              { (# ipv24, ipv25 #) ->
                                              case $wrunbench
                                                     @ Bool
                                                     @ Bool
                                                     integer-gmp-1.0.1.0:GHC.Integer.Type.gtInteger
                                                     GHC.Classes.gtInt
                                                     x
                                                     x1
                                                     x2
                                                     ipv24
                                              of
                                              { (# ipv26, ipv27 #) ->
                                              $wrunbench
                                                @ Bool
                                                @ Bool
                                                integer-gmp-1.0.1.0:GHC.Integer.Type.geInteger
                                                GHC.Classes.geInt
                                                x
                                                x1
                                                x2
                                                ipv26
                                              }
                                              }
                                              }
                                              }
                                              }
                                              }
                                              }
                                              }
                                              }
                                              }
                                              }
                                              }
                                              };
                                            : ipv2 ipv3 -> case lvl4 of wild10 { }
                                          }
                                      };
                                    : ipv2 ipv3 -> case lvl4 of wild8 { }
                                  }
                              };
                            : ipv2 ipv3 -> case lvl4 of wild6 { }
                          }
                      };
                    : ipv2 ipv3 -> $wfail ipv
                  }
              }
          }
      }
      }

-- RHS size: {terms: 1, types: 0, coercions: 3, joins: 0/0}
main :: IO ()
[GblId,
 Arity=1,
 Str=<S,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.N:IO[0] <()>_R)
                       :: (GHC.Prim.State# GHC.Prim.RealWorld
                           -> (# GHC.Prim.State# GHC.Prim.RealWorld, () #) :: *)
                          ~R# (IO () :: *))}]
main
  = Main.main1
    `cast` (Sym (GHC.Types.N:IO[0] <()>_R)
            :: (GHC.Prim.State# GHC.Prim.RealWorld
                -> (# GHC.Prim.State# GHC.Prim.RealWorld, () #) :: *)
               ~R# (IO () :: *))

-- RHS size: {terms: 2, types: 1, coercions: 3, joins: 0/0}
Main.main2
  :: GHC.Prim.State# GHC.Prim.RealWorld
     -> (# GHC.Prim.State# GHC.Prim.RealWorld, () #)
[GblId,
 Arity=1,
 Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
         WorkFree=True, Expandable=True, Guidance=IF_ARGS [] 20 60}]
Main.main2
  = GHC.TopHandler.runMainIO1
      @ ()
      (Main.main1
       `cast` (Sym (GHC.Types.N:IO[0] <()>_R)
               :: (GHC.Prim.State# GHC.Prim.RealWorld
                   -> (# GHC.Prim.State# GHC.Prim.RealWorld, () #) :: *)
                  ~R# (IO () :: *)))

-- RHS size: {terms: 1, types: 0, coercions: 3, joins: 0/0}
:Main.main :: IO ()
[GblId,
 Arity=1,
 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.main2
               `cast` (Sym (GHC.Types.N:IO[0] <()>_R)
                       :: (GHC.Prim.State# GHC.Prim.RealWorld
                           -> (# GHC.Prim.State# GHC.Prim.RealWorld, () #) :: *)
                          ~R# (IO () :: *))}]
:Main.main
  = Main.main2
    `cast` (Sym (GHC.Types.N:IO[0] <()>_R)
            :: (GHC.Prim.State# GHC.Prim.RealWorld
                -> (# GHC.Prim.State# GHC.Prim.RealWorld, () #) :: *)
               ~R# (IO () :: *))

Changed text

Open file


==================== Tidy Core ====================
2018-03-31 08:12:01.1554222 UTC

Result size of Tidy Core
  = {terms: 678, types: 573, coercions: 19, joins: 1/23}

-- RHS size: {terms: 1, types: 0, coercions: 0, joins: 0/0}
Main.$trModule4 :: GHC.Prim.Addr#
[GblId,
 Caf=NoCafRefs,
 Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
         WorkFree=True, Expandable=True, Guidance=IF_ARGS [] 20 0}]
Main.$trModule4 = "main"#

-- RHS size: {terms: 2, types: 0, coercions: 0, joins: 0/0}
Main.$trModule3 :: GHC.Types.TrName
[GblId,
 Caf=NoCafRefs,
 Str=m1,
 Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
         WorkFree=True, Expandable=True, Guidance=IF_ARGS [] 10 20}]
Main.$trModule3 = GHC.Types.TrNameS Main.$trModule4

-- RHS size: {terms: 1, types: 0, coercions: 0, joins: 0/0}
Main.$trModule2 :: GHC.Prim.Addr#
[GblId,
 Caf=NoCafRefs,
 Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
         WorkFree=True, Expandable=True, Guidance=IF_ARGS [] 20 0}]
Main.$trModule2 = "Main"#

-- RHS size: {terms: 2, types: 0, coercions: 0, joins: 0/0}
Main.$trModule1 :: GHC.Types.TrName
[GblId,
 Caf=NoCafRefs,
 Str=m1,
 Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
         WorkFree=True, Expandable=True, Guidance=IF_ARGS [] 10 20}]
Main.$trModule1 = GHC.Types.TrNameS Main.$trModule2

-- RHS size: {terms: 3, types: 0, coercions: 0, joins: 0/0}
Main.$trModule :: GHC.Types.Module
[GblId,
 Caf=NoCafRefs,
 Str=m,
 Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
         WorkFree=True, Expandable=True, Guidance=IF_ARGS [] 10 30}]
Main.$trModule = GHC.Types.Module Main.$trModule3 Main.$trModule1

Rec {
-- RHS size: {terms: 16, types: 20, coercions: 0, joins: 0/0}
poly_seqlist
  :: forall a.
     [a]
     -> GHC.Prim.State# GHC.Prim.RealWorld
     -> (# GHC.Prim.State# GHC.Prim.RealWorld, () #)
[GblId, Arity=2, Caf=NoCafRefs, Str=<S,1*U><S,U>, Unf=OtherCon []]
poly_seqlist
  = \ (@ a)
      (ds :: [a])
      (eta :: GHC.Prim.State# GHC.Prim.RealWorld) ->
      case ds of {
        [] -> (# eta, GHC.Tuple.() #);
        : x xs -> case x of { __DEFAULT -> poly_seqlist @ a xs eta }
      }
end Rec }

-- RHS size: {terms: 1, types: 0, coercions: 0, joins: 0/0}
lvl :: Integer
[GblId, Caf=NoCafRefs, Unf=OtherCon []]
lvl = 0

-- RHS size: {terms: 412, types: 203, coercions: 0, joins: 1/23}
$wrunbench
  :: forall a b.
     (Integer -> Integer -> a)
     -> (Int -> Int -> b)
     -> Integer
     -> Integer
     -> Integer
     -> GHC.Prim.State# GHC.Prim.RealWorld
     -> (# GHC.Prim.State# GHC.Prim.RealWorld, () #)
[GblId,
 Arity=6,
 Str=<L,C(C1(U))><L,C(C1(U))><S,U><S,U><S,U><S,U>,
 Unf=OtherCon []]
$wrunbench
  = \ (@ a)
      (@ b)
      (w :: Integer -> Integer -> a)
      (w1 :: Int -> Int -> b)
      (w2 :: Integer)
      (w3 :: Integer)
      (w4 :: Integer)
      (w5 :: GHC.Prim.State# GHC.Prim.RealWorld) ->
      case integer-gmp-1.0.1.0:GHC.Integer.Type.integerToInt w2 of wild
      { __DEFAULT ->
      case integer-gmp-1.0.1.0:GHC.Integer.Type.integerToInt w3 of wild1
      { __DEFAULT ->
      case integer-gmp-1.0.1.0:GHC.Integer.Type.integerToInt w4 of wild2
      { __DEFAULT ->
      let {
        x2 [Dmd=<S,U>] :: GHC.Prim.Int#
        [LclId]
        x2 = GHC.Prim.+# wild wild1 } in
      let {
        c [Dmd=<L,C(C1(U))>] :: Int -> [b] -> [b]
        [LclId, Arity=2, Str=<L,U><L,U>, Unf=OtherCon []]
        c = \ (ds :: Int) (ds1 [OS=OneShot] :: [b]) ->
              let {
                x1 [Dmd=<S,U>] :: GHC.Prim.Int#
                [LclId]
                x1 = GHC.Prim.+# wild wild1 } in
              case GHC.Prim.>=# x1 wild of {
                __DEFAULT ->
                  case GHC.Prim.tagToEnum# @ Bool (GHC.Prim.># wild2 x1) of single
                  { __DEFAULT ->
                  case GHC.Prim.># wild2 wild of {
                    __DEFAULT ->
                      let {
                        delta [Dmd=<S,U>] :: GHC.Prim.Int#
                        [LclId]
                        delta = GHC.Prim.-# x1 wild } in
                      let {
                        y' :: GHC.Prim.Int#
                        [LclId]
                        y' = GHC.Prim.-# wild2 delta } in
                      GHC.Types.:
                        @ b
                        (w1 ds (GHC.Types.I# wild))
                        (case single of {
                           False ->
                             case GHC.Prim.<# wild y' of {
                               __DEFAULT ->
                                 letrec {
                                   go_dn [Occ=LoopBreaker] :: GHC.Prim.Int# -> [b]
                                   [LclId, Arity=1, Str=<L,U>, Unf=OtherCon []]
                                   go_dn
                                     = \ (x :: GHC.Prim.Int#) ->
                                         GHC.Types.:
                                           @ b
                                           (w1 ds (GHC.Types.I# x))
                                           (case GHC.Prim.<# x y' of {
                                              __DEFAULT -> go_dn (GHC.Prim.+# x delta);
                                              1# -> ds1
                                            }); } in
                                 go_dn (GHC.Prim.+# wild delta);
                               1# -> ds1
                             };
                           True -> ds1
                         });
                    1# -> ds1
                  }
                  };
                1# ->
                  case GHC.Prim.tagToEnum# @ Bool (GHC.Prim.<# wild2 x1) of single
                  { __DEFAULT ->
                  case GHC.Prim.<# wild2 wild of {
                    __DEFAULT ->
                      let {
                        delta [Dmd=<S,U>] :: GHC.Prim.Int#
                        [LclId]
                        delta = GHC.Prim.-# x1 wild } in
                      let {
                        y' :: GHC.Prim.Int#
                        [LclId]
                        y' = GHC.Prim.-# wild2 delta } in
                      GHC.Types.:
                        @ b
                        (w1 ds (GHC.Types.I# wild))
                        (case single of {
                           False ->
                             case GHC.Prim.># wild y' of {
                               __DEFAULT ->
                                 letrec {
                                   go_up [Occ=LoopBreaker] :: GHC.Prim.Int# -> [b]
                                   [LclId, Arity=1, Str=<L,U>, Unf=OtherCon []]
                                   go_up
                                     = \ (x :: GHC.Prim.Int#) ->
                                         GHC.Types.:
                                           @ b
                                           (w1 ds (GHC.Types.I# x))
                                           (case GHC.Prim.># x y' of {
                                              __DEFAULT -> go_up (GHC.Prim.+# x delta);
                                              1# -> ds1
                                            }); } in
                                 go_up (GHC.Prim.+# wild delta);
                               1# -> ds1
                             };
                           True -> ds1
                         });
                    1# -> ds1
                  }
                  }
              } } in
      join {
        $j [Dmd=<L,1*C1(C1(U(U,U)))>]
          :: GHC.Prim.State# GHC.Prim.RealWorld
             -> () -> (# GHC.Prim.State# GHC.Prim.RealWorld, () #)
        [LclId[JoinId(2)], Arity=2, Str=<S,U><L,A>, Unf=OtherCon []]
        $j (ipv [OS=OneShot] :: GHC.Prim.State# GHC.Prim.RealWorld)
           _ [Occ=Dead, OS=OneShot]
          = let {
              delta [Dmd=<S,U>] :: Integer
              [LclId]
              delta
                = integer-gmp-1.0.1.0:GHC.Integer.Type.minusInteger
                    (integer-gmp-1.0.1.0:GHC.Integer.Type.plusInteger w2 w3) w2 } in
            let {
              lvl5 [Dmd=<L,U(U)>] :: Int
              [LclId]
              lvl5
                = case integer-gmp-1.0.1.0:GHC.Integer.Type.geInteger# delta lvl
                  of v
                  { __DEFAULT ->
                  GHC.Types.I# v
                  } } in
            let {
              c1 [Dmd=<L,C(C1(U))>] :: Integer -> [a] -> [a]
              [LclId, Arity=2, Str=<L,U><L,U>, Unf=OtherCon []]
              c1
                = \ (ds :: Integer) (ds1 [OS=OneShot] :: [a]) ->
                    case lvl5 of { GHC.Types.I# v1 ->
                    case v1 of {
                      __DEFAULT ->
                        letrec {
                          go [Occ=LoopBreaker] :: Integer -> [a]
                          [LclId, Arity=1, Str=<S,U>, Unf=OtherCon []]
                          go
                            = \ (x :: Integer) ->
                                case integer-gmp-1.0.1.0:GHC.Integer.Type.ltInteger# x w4 of {
                                  __DEFAULT ->
                                    GHC.Types.:
                                      @ a
                                      (w ds x)
                                      (go
                                         (integer-gmp-1.0.1.0:GHC.Integer.Type.plusInteger
                                            x delta));
                                  1# -> ds1
                                }; } in
                        go w2;
                      1# ->
                        letrec {
                          go [Occ=LoopBreaker] :: Integer -> [a]
                          [LclId, Arity=1, Str=<S,U>, Unf=OtherCon []]
                          go
                            = \ (x :: Integer) ->
                                case integer-gmp-1.0.1.0:GHC.Integer.Type.gtInteger# x w4 of {
                                  __DEFAULT ->
                                    GHC.Types.:
                                      @ a
                                      (w ds x)
                                      (go
                                         (integer-gmp-1.0.1.0:GHC.Integer.Type.plusInteger
                                            x delta));
                                  1# -> ds1
                                }; } in
                        go w2
                    }
                    } } in
            case integer-gmp-1.0.1.0:GHC.Integer.Type.geInteger# delta lvl of {
              __DEFAULT ->
                letrec {
                  go [Occ=LoopBreaker] :: Integer -> [a]
                  [LclId, Arity=1, Str=<S,U>, Unf=OtherCon []]
                  go
                    = \ (x :: Integer) ->
                        case integer-gmp-1.0.1.0:GHC.Integer.Type.ltInteger# x w4 of {
                          __DEFAULT ->
                            c1
                              x (go (integer-gmp-1.0.1.0:GHC.Integer.Type.plusInteger x delta));
                          1# -> GHC.Types.[] @ a
                        }; } in
                case poly_seqlist @ a (go w2) ipv of { (# ipv2, ipv3 #) ->
                (# ipv2, GHC.Tuple.() #)
                };
              1# ->
                letrec {
                  go [Occ=LoopBreaker] :: Integer -> [a]
                  [LclId, Arity=1, Str=<S,U>, Unf=OtherCon []]
                  go
                    = \ (x :: Integer) ->
                        case integer-gmp-1.0.1.0:GHC.Integer.Type.gtInteger# x w4 of {
                          __DEFAULT ->
                            c1
                              x (go (integer-gmp-1.0.1.0:GHC.Integer.Type.plusInteger x delta));
                          1# -> GHC.Types.[] @ a
                        }; } in
                case poly_seqlist @ a (go w2) ipv of { (# ipv2, ipv3 #) ->
                (# ipv2, GHC.Tuple.() #)
                }
            } } in
      case GHC.Prim.>=# x2 wild of {
        __DEFAULT ->
          case GHC.Prim.tagToEnum# @ Bool (GHC.Prim.># wild2 x2) of single
          { __DEFAULT ->
          case GHC.Prim.># wild2 wild of {
            __DEFAULT ->
              let {
                delta [Dmd=<S,U>] :: GHC.Prim.Int#
                [LclId]
                delta = GHC.Prim.-# x2 wild } in
              let {
                y' :: GHC.Prim.Int#
                [LclId]
                y' = GHC.Prim.-# wild2 delta } in
              case poly_seqlist
                     @ b
                     (c (GHC.Types.I# wild)
                        (case single of {
                           False ->
                             case GHC.Prim.<# wild y' of {
                               __DEFAULT ->
                                 letrec {
                                   go_dn [Occ=LoopBreaker] :: GHC.Prim.Int# -> [b]
                                   [LclId, Arity=1, Str=<L,U>, Unf=OtherCon []]
                                   go_dn
                                     = \ (x :: GHC.Prim.Int#) ->
                                         c (GHC.Types.I# x)
                                           (case GHC.Prim.<# x y' of {
                                              __DEFAULT -> go_dn (GHC.Prim.+# x delta);
                                              1# -> GHC.Types.[] @ b
                                            }); } in
                                 go_dn (GHC.Prim.+# wild delta);
                               1# -> GHC.Types.[] @ b
                             };
                           True -> GHC.Types.[] @ b
                         }))
                     w5
              of
              { (# ipv, ipv1 #) ->
              jump $j ipv ipv1
              };
            1# -> jump $j w5 GHC.Tuple.()
          }
          };
        1# ->
          case GHC.Prim.tagToEnum# @ Bool (GHC.Prim.<# wild2 x2) of single
          { __DEFAULT ->
          case GHC.Prim.<# wild2 wild of {
            __DEFAULT ->
              let {
                delta [Dmd=<S,U>] :: GHC.Prim.Int#
                [LclId]
                delta = GHC.Prim.-# x2 wild } in
              let {
                y' :: GHC.Prim.Int#
                [LclId]
                y' = GHC.Prim.-# wild2 delta } in
              case poly_seqlist
                     @ b
                     (c (GHC.Types.I# wild)
                        (case single of {
                           False ->
                             case GHC.Prim.># wild y' of {
                               __DEFAULT ->
                                 letrec {
                                   go_up [Occ=LoopBreaker] :: GHC.Prim.Int# -> [b]
                                   [LclId, Arity=1, Str=<L,U>, Unf=OtherCon []]
                                   go_up
                                     = \ (x :: GHC.Prim.Int#) ->
                                         c (GHC.Types.I# x)
                                           (case GHC.Prim.># x y' of {
                                              __DEFAULT -> go_up (GHC.Prim.+# x delta);
                                              1# -> GHC.Types.[] @ b
                                            }); } in
                                 go_up (GHC.Prim.+# wild delta);
                               1# -> GHC.Types.[] @ b
                             };
                           True -> GHC.Types.[] @ b
                         }))
                     w5
              of
              { (# ipv, ipv1 #) ->
              jump $j ipv ipv1
              };
            1# -> jump $j w5 GHC.Tuple.()
          }
          }
      }
      }
      }
      }

-- RHS size: {terms: 1, types: 0, coercions: 0, joins: 0/0}
lvl1 :: GHC.Prim.Addr#
[GblId, Caf=NoCafRefs, Unf=OtherCon []]
lvl1 = "Pattern match failure in do expression at Main.hs:9:3-12"#

-- RHS size: {terms: 2, types: 0, coercions: 0, joins: 0/0}
lvl2 :: [Char]
[GblId]
lvl2 = GHC.CString.unpackCString# lvl1

-- RHS size: {terms: 5, types: 9, coercions: 10, joins: 0/0}
$wfail
  :: GHC.Prim.State# GHC.Prim.RealWorld
     -> (# GHC.Prim.State# GHC.Prim.RealWorld, () #)
[GblId, Arity=1, Str=<S,U>, Unf=OtherCon []]
$wfail
  = \ (w :: GHC.Prim.State# GHC.Prim.RealWorld) ->
      ((GHC.Magic.noinline
          @ (forall a. [Char] -> IO a)
          (GHC.IO.failIO1
           `cast` (forall (a :: <*>_N).
                   <String>_R ->_R Sym (GHC.Types.N:IO[0] <a>_R)
                   :: (forall a.
                       String
                       -> GHC.Prim.State# GHC.Prim.RealWorld
                       -> (# GHC.Prim.State# GHC.Prim.RealWorld, a #) :: *)
                      ~R# (forall a. String -> IO a :: *)))
          @ ()
          lvl2)
       `cast` (GHC.Types.N:IO[0] <()>_R
               :: (IO () :: *)
                  ~R# (GHC.Prim.State# GHC.Prim.RealWorld
                       -> (# GHC.Prim.State# GHC.Prim.RealWorld, () #) :: *)))
        w

-- RHS size: {terms: 2, types: 2, coercions: 0, joins: 0/0}
lvl3 :: Integer
[GblId, Str=x]
lvl3
  = errorWithoutStackTrace
      @ 'GHC.Types.LiftedRep @ Integer Text.Read.readEither5

-- RHS size: {terms: 2, types: 2, coercions: 0, joins: 0/0}
lvl4 :: Integer
[GblId, Str=x]
lvl4
  = errorWithoutStackTrace
      @ 'GHC.Types.LiftedRep @ Integer Text.Read.readEither2

-- RHS size: {terms: 207, types: 254, coercions: 0, joins: 0/0}
Main.main1
  :: GHC.Prim.State# GHC.Prim.RealWorld
     -> (# GHC.Prim.State# GHC.Prim.RealWorld, () #)
[GblId, Arity=1, Str=<S,U>, Unf=OtherCon []]
Main.main1
  = \ (s :: GHC.Prim.State# GHC.Prim.RealWorld) ->
      case System.Environment.getArgs1 s of { (# ipv, ipv1 #) ->
      case ipv1 of {
        [] -> $wfail ipv;
        : _1 ds ->
          case ds of {
            [] -> $wfail ipv;
            : _2 ds2 ->
              case ds2 of {
                [] -> $wfail ipv;
                : _3 ds3 ->
                  case ds3 of {
                    [] ->
                      case Text.Read.readEither8
                             @ Integer
                             (Text.ParserCombinators.ReadP.run
                                @ Integer
                                (GHC.Read.$fReadInteger_$sreadNumber
                                   GHC.Read.$fReadInteger2
                                   Text.ParserCombinators.ReadPrec.minPrec
                                   @ Integer
                                   (Text.Read.readEither7 @ Integer))
                                _1)
                      of {
                        [] -> case lvl3 of wild5 { };
                        : x ds4 ->
                          case ds4 of {
                            [] ->
                              case Text.Read.readEither8
                                     @ Integer
                                     (Text.ParserCombinators.ReadP.run
                                        @ Integer
                                        (GHC.Read.$fReadInteger_$sreadNumber
                                           GHC.Read.$fReadInteger2
                                           Text.ParserCombinators.ReadPrec.minPrec
                                           @ Integer
                                           (Text.Read.readEither7 @ Integer))
                                        _2)
                              of {
                                [] -> case lvl3 of wild7 { };
                                : x1 ds5 ->
                                  case ds5 of {
                                    [] ->
                                      case Text.Read.readEither8
                                             @ Integer
                                             (Text.ParserCombinators.ReadP.run
                                                @ Integer
                                                (GHC.Read.$fReadInteger_$sreadNumber
                                                   GHC.Read.$fReadInteger2
                                                   Text.ParserCombinators.ReadPrec.minPrec
                                                   @ Integer
                                                   (Text.Read.readEither7 @ Integer))
                                                _3)
                                      of {
                                        [] -> case lvl3 of wild9 { };
                                        : x2 ds6 ->
                                          case ds6 of {
                                            [] ->
                                              case $wrunbench
                                                     @ Integer
                                                     @ Int
                                                     integer-gmp-1.0.1.0:GHC.Integer.Type.plusInteger
                                                     GHC.Num.$fNumInt_$c+
                                                     x
                                                     x1
                                                     x2
                                                     ipv
                                              of
                                              { (# ipv2, ipv3 #) ->
                                              case $wrunbench
                                                     @ Integer
                                                     @ Int
                                                     integer-gmp-1.0.1.0:GHC.Integer.Type.minusInteger
                                                     GHC.Num.$fNumInt_$c-
                                                     x
                                                     x1
                                                     x2
                                                     ipv2
                                              of
                                              { (# ipv4, ipv5 #) ->
                                              case $wrunbench
                                                     @ Integer
                                                     @ Int
                                                     integer-gmp-1.0.1.0:GHC.Integer.Type.timesInteger
                                                     GHC.Num.$fNumInt_$c*
                                                     x
                                                     x1
                                                     x2
                                                     ipv4
                                              of
                                              { (# ipv6, ipv7 #) ->
                                              case $wrunbench
                                                     @ Integer
                                                     @ Int
                                                     GHC.Real.$fIntegralInteger_$cdiv
                                                     GHC.Real.$fIntegralInt_$cdiv
                                                     x
                                                     x1
                                                     x2
                                                     ipv6
                                              of
                                              { (# ipv8, ipv9 #) ->
                                              case $wrunbench
                                                     @ Integer
                                                     @ Int
                                                     GHC.Real.$fIntegralInteger_$cmod
                                                     GHC.Real.$fIntegralInt_$cmod
                                                     x
                                                     x1
                                                     x2
                                                     ipv8
                                              of
                                              { (# ipv10, ipv11 #) ->
                                              case $wrunbench
                                                     @ Integer
                                                     @ Int
                                                     GHC.Real.$fIntegralInteger_$cquot
                                                     GHC.Real.$fIntegralInt_$cquot
                                                     x
                                                     x1
                                                     x2
                                                     ipv10
                                              of
                                              { (# ipv12, ipv13 #) ->
                                              case $wrunbench
                                                     @ Integer
                                                     @ Int
                                                     GHC.Real.$fIntegralInteger_$crem
                                                     GHC.Real.$fIntegralInt_$crem
                                                     x
                                                     x1
                                                     x2
                                                     ipv12
                                              of
                                              { (# ipv14, ipv15 #) ->
                                              case $wrunbench
                                                     @ Integer
                                                     @ Int
                                                     integer-gmp-1.0.1.0:GHC.Integer.Type.gcdInteger
                                                     GHC.Real.gcdInt'
                                                     x
                                                     x1
                                                     x2
                                                     ipv14
                                              of
                                              { (# ipv16, ipv17 #) ->
                                              case $wrunbench
                                                     @ Integer
                                                     @ Int
                                                     integer-gmp-1.0.1.0:GHC.Integer.Type.lcmInteger
                                                     GHC.Real.lcm_$slcm1
                                                     x
                                                     x1
                                                     x2
                                                     ipv16
                                              of
                                              { (# ipv18, ipv19 #) ->
                                              case $wrunbench
                                                     @ Bool
                                                     @ Bool
                                                     integer-gmp-1.0.1.0:GHC.Integer.Type.eqInteger
                                                     GHC.Classes.eqInt
                                                     x
                                                     x1
                                                     x2
                                                     ipv18
                                              of
                                              { (# ipv20, ipv21 #) ->
                                              case $wrunbench
                                                     @ Bool
                                                     @ Bool
                                                     integer-gmp-1.0.1.0:GHC.Integer.Type.ltInteger
                                                     GHC.Classes.ltInt
                                                     x
                                                     x1
                                                     x2
                                                     ipv20
                                              of
                                              { (# ipv22, ipv23 #) ->
                                              case $wrunbench
                                                     @ Bool
                                                     @ Bool
                                                     integer-gmp-1.0.1.0:GHC.Integer.Type.leInteger
                                                     GHC.Classes.leInt
                                                     x
                                                     x1
                                                     x2
                                                     ipv22
                                              of
                                              { (# ipv24, ipv25 #) ->
                                              case $wrunbench
                                                     @ Bool
                                                     @ Bool
                                                     integer-gmp-1.0.1.0:GHC.Integer.Type.gtInteger
                                                     GHC.Classes.gtInt
                                                     x
                                                     x1
                                                     x2
                                                     ipv24
                                              of
                                              { (# ipv26, ipv27 #) ->
                                              $wrunbench
                                                @ Bool
                                                @ Bool
                                                integer-gmp-1.0.1.0:GHC.Integer.Type.geInteger
                                                GHC.Classes.geInt
                                                x
                                                x1
                                                x2
                                                ipv26
                                              }
                                              }
                                              }
                                              }
                                              }
                                              }
                                              }
                                              }
                                              }
                                              }
                                              }
                                              }
                                              };
                                            : ipv2 ipv3 -> case lvl4 of wild10 { }
                                          }
                                      };
                                    : ipv2 ipv3 -> case lvl4 of wild8 { }
                                  }
                              };
                            : ipv2 ipv3 -> case lvl4 of wild6 { }
                          }
                      };
                    : ipv2 ipv3 -> $wfail ipv
                  }
              }
          }
      }
      }

-- RHS size: {terms: 1, types: 0, coercions: 3, joins: 0/0}
main :: IO ()
[GblId,
 Arity=1,
 Str=<S,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.N:IO[0] <()>_R)
                       :: (GHC.Prim.State# GHC.Prim.RealWorld
                           -> (# GHC.Prim.State# GHC.Prim.RealWorld, () #) :: *)
                          ~R# (IO () :: *))}]
main
  = Main.main1
    `cast` (Sym (GHC.Types.N:IO[0] <()>_R)
            :: (GHC.Prim.State# GHC.Prim.RealWorld
                -> (# GHC.Prim.State# GHC.Prim.RealWorld, () #) :: *)
               ~R# (IO () :: *))

-- RHS size: {terms: 2, types: 1, coercions: 3, joins: 0/0}
Main.main2
  :: GHC.Prim.State# GHC.Prim.RealWorld
     -> (# GHC.Prim.State# GHC.Prim.RealWorld, () #)
[GblId,
 Arity=1,
 Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
         WorkFree=True, Expandable=True, Guidance=IF_ARGS [] 20 60}]
Main.main2
  = GHC.TopHandler.runMainIO1
      @ ()
      (Main.main1
       `cast` (Sym (GHC.Types.N:IO[0] <()>_R)
               :: (GHC.Prim.State# GHC.Prim.RealWorld
                   -> (# GHC.Prim.State# GHC.Prim.RealWorld, () #) :: *)
                  ~R# (IO () :: *)))

-- RHS size: {terms: 1, types: 0, coercions: 3, joins: 0/0}
:Main.main :: IO ()
[GblId,
 Arity=1,
 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.main2
               `cast` (Sym (GHC.Types.N:IO[0] <()>_R)
                       :: (GHC.Prim.State# GHC.Prim.RealWorld
                           -> (# GHC.Prim.State# GHC.Prim.RealWorld, () #) :: *)
                          ~R# (IO () :: *))}]
:Main.main
  = Main.main2
    `cast` (Sym (GHC.Types.N:IO[0] <()>_R)
            :: (GHC.Prim.State# GHC.Prim.RealWorld
                -> (# GHC.Prim.State# GHC.Prim.RealWorld, () #) :: *)
               ~R# (IO () :: *))