Comparer le texte

Trouver la différence entre deux fichiers texte

Éditeur live
Masquer les espaces
Cacher identiques
Sans retour à la ligne
Vue
Niveau de précision
Styles de texte
Coloration syntaxique

Untitled diff

Créé Le diff n'expire jamais
159 suppressions
564 lignes
170 ajouts
569 lignes


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


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


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


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


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


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


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


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


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


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


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


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


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


-- RHS size: {terms: 207, types: 254, coercions: 0, joins: 0/0}
-- RHS size: {terms: 207, types: 254, coercions: 0, joins: 0/0}
Main.main1
Main.main1
:: GHC.Prim.State# GHC.Prim.RealWorld
:: GHC.Prim.State# GHC.Prim.RealWorld
-> (# GHC.Prim.State# GHC.Prim.RealWorld, () #)
-> (# GHC.Prim.State# GHC.Prim.RealWorld, () #)
[GblId, Arity=1, Str=<S,U>, Unf=OtherCon []]
[GblId, Arity=1, Str=<S,U>, Unf=OtherCon []]
Main.main1
Main.main1
= \ (s :: GHC.Prim.State# GHC.Prim.RealWorld) ->
= \ (s :: GHC.Prim.State# GHC.Prim.RealWorld) ->
case System.Environment.getArgs1 s of { (# ipv, ipv1 #) ->
case System.Environment.getArgs1 s of { (# ipv, ipv1 #) ->
case ipv1 of {
case ipv1 of {
[] -> $wfail ipv;
[] -> $wfail ipv;
: _1 ds ->
: _1 ds ->
case ds of {
case ds of {
[] -> $wfail ipv;
[] -> $wfail ipv;
: _2 ds2 ->
: _2 ds2 ->
case ds2 of {
case ds2 of {
[] -> $wfail ipv;
[] -> $wfail ipv;
: _3 ds3 ->
: _3 ds3 ->
case ds3 of {
case ds3 of {
[] ->
[] ->
case Text.Read.readEither8
case Text.Read.readEither8
@ Integer
@ Integer
(Text.ParserCombinators.ReadP.run
(Text.ParserCombinators.ReadP.run
@ Integer
@ Integer
(GHC.Read.$fReadInteger_$sreadNumber
(GHC.Read.$fReadInteger_$sreadNumber
GHC.Read.$fReadInteger2
GHC.Read.$fReadInteger2
Text.ParserCombinators.ReadPrec.minPrec
Text.ParserCombinators.ReadPrec.minPrec
@ Integer
@ Integer
(Text.Read.readEither7 @ Integer))
(Text.Read.readEither7 @ Integer))
_1)
_1)
of {
of {
[] -> case lvl3 of wild5 { };
[] -> case lvl3 of wild5 { };
: x ds4 ->
: x ds4 ->
case ds4 of {
case ds4 of {
[] ->
[] ->
case Text.Read.readEither8
case Text.Read.readEither8
@ Integer
@ Integer
(Text.ParserCombinators.ReadP.run
(Text.ParserCombinators.ReadP.run
@ Integer
@ Integer
(GHC.Read.$fReadInteger_$sreadNumber
(GHC.Read.$fReadInteger_$sreadNumber
GHC.Read.$fReadInteger2
GHC.Read.$fReadInteger2
Text.ParserCombinators.ReadPrec.minPrec
Text.ParserCombinators.ReadPrec.minPrec
@ Integer
@ Integer
(Text.Read.readEither7 @ Integer))
(Text.Read.readEither7 @ Integer))
_2)
_2)
of {
of {
[] -> case lvl3 of wild7 { };
[] -> case lvl3 of wild7 { };
: x1 ds5 ->
: x1 ds5 ->
case ds5 of {
case ds5 of {
[] ->
[] ->
case Text.Read.readEither8
case Text.Read.readEither8
@ Integer
@ Integer
(Text.ParserCombinators.ReadP.run
(Text.ParserCombinators.ReadP.run
@ Integer
@ Integer
(GHC.Read.$fReadInteger_$sreadNumber
(GHC.Read.$fReadInteger_$sreadNumber
GHC.Read.$fReadInteger2
GHC.Read.$fReadInteger2
Text.ParserCombinators.ReadPrec.minPrec
Text.ParserCombinators.ReadPrec.minPrec
@ Integer
@ Integer
(Text.Read.readEither7 @ Integer))
(Text.Read.readEither7 @ Integer))
_3)
_3)
of {
of {
[] -> case lvl3 of wild9 { };
[] -> case lvl3 of wild9 { };
: x2 ds6 ->
: x2 ds6 ->
case ds6 of {
case ds6 of {
[] ->
[] ->
case $wrunbench
case $wrunbench
@ Integer
@ Integer
@ Int
@ Int
integer-gmp-1.0.1.0:GHC.Integer.Type.plusInteger
integer-gmp-1.0.1.0:GHC.Integer.Type.plusInteger
GHC.Num.$fNumInt_$c+
GHC.Num.$fNumInt_$c+
x
x
x1
x1
x2
x2
ipv
ipv
of
of
{ (# ipv2, ipv3 #) ->
{ (# ipv2, ipv3 #) ->
case $wrunbench
case $wrunbench
@ Integer
@ Integer
@ Int
@ Int
integer-gmp-1.0.1.0:GHC.Integer.Type.minusInteger
integer-gmp-1.0.1.0:GHC.Integer.Type.minusInteger
GHC.Num.$fNumInt_$c-
GHC.Num.$fNumInt_$c-
x
x
x1
x1
x2
x2
ipv2
ipv2
of
of
{ (# ipv4, ipv5 #) ->
{ (# ipv4, ipv5 #) ->
case $wrunbench
case $wrunbench
@ Integer
@ Integer
@ Int
@ Int
integer-gmp-1.0.1.0:GHC.Integer.Type.timesInteger
integer-gmp-1.0.1.0:GHC.Integer.Type.timesInteger
GHC.Num.$fNumInt_$c*
GHC.Num.$fNumInt_$c*
x
x
x1
x1
x2
x2
ipv4
ipv4
of
of
{ (# ipv6, ipv7 #) ->
{ (# ipv6, ipv7 #) ->
case $wrunbench
case $wrunbench
@ Integer
@ Integer
@ Int
@ Int
GHC.Real.$fIntegralInteger_$cdiv
GHC.Real.$fIntegralInteger_$cdiv
GHC.Real.$fIntegralInt_$cdiv
GHC.Real.$fIntegralInt_$cdiv
x
x
x1
x1
x2
x2
ipv6
ipv6
of
of
{ (# ipv8, ipv9 #) ->
{ (# ipv8, ipv9 #) ->
case $wrunbench
case $wrunbench
@ Integer
@ Integer
@ Int
@ Int
GHC.Real.$fIntegralInteger_$cmod
GHC.Real.$fIntegralInteger_$cmod
GHC.Real.$fIntegralInt_$cmod
GHC.Real.$fIntegralInt_$cmod
x
x
x1
x1
x2
x2
ipv8
ipv8
of
of
{ (# ipv10, ipv11 #) ->
{ (# ipv10, ipv11 #) ->
case $wrunbench
case $wrunbench
@ Integer
@ Integer
@ Int
@ Int
GHC.Real.$fIntegralInteger_$cquot
GHC.Real.$fIntegralInteger_$cquot
GHC.Real.$fIntegralInt_$cquot
GHC.Real.$fIntegralInt_$cquot
x
x
x1
x1
x2
x2
ipv10
ipv10
of
of
{ (# ipv12, ipv13 #) ->
{ (# ipv12, ipv13 #) ->
case $wrunbench
case $wrunbench
@ Integer
@ Integer
@ Int
@ Int
GHC.Real.$fIntegralInteger_$crem
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
{ (# ipv1
Différences enregistrées