Skip to content

Instantly share code, notes, and snippets.

@chrisdone

chrisdone/core.hs

Created November 9, 2019 12:33
Show Gist options

  • Select an option

    Learn more about clone URLs
  • Save chrisdone/af15c5be09d612fdc42c4e48ee08a9e5 to your computer and use it in GitHub Desktop.

Select an option

Learn more about clone URLs
Save chrisdone/af15c5be09d612fdc42c4e48ee08a9e5 to your computer and use it in GitHub Desktop.
Download ZIP
Raw
core.hs
[2 of 2] Compiling Main ( hask-tok3.hs, hask-tok3.o )
==================== Tidy Core ====================
Result size of Tidy Core
= {terms: 2,614, types: 3,717, coercions: 1,413, joins: 31/63}
-- RHS size: {terms: 16, types: 9, coercions: 0, joins: 0/0}
Main.$WPoint [InlPrag=INLINE[2]] :: Int -> Int -> Int -> Point
[GblId[DataConWrapper],
Arity=3,
Caf=NoCafRefs,
Str=<S,U><S,U><S,U>m,
Unf=Unf{Src=InlineStable, TopLvl=True, Value=True, ConLike=True,
WorkFree=True, Expandable=True,
Guidance=ALWAYS_IF(arity=3,unsat_ok=True,boring_ok=False)
Tmpl= \ (dt_a53g [Occ=Once!] :: Int)
(dt_a53h [Occ=Once!] :: Int)
(dt_a53i [Occ=Once!] :: Int) ->
case dt_a53g of { GHC.Types.I# dt_a53j [Occ=Once] ->
case dt_a53h of { GHC.Types.I# dt_a53k [Occ=Once] ->
case dt_a53i of { GHC.Types.I# dt_a53l [Occ=Once] ->
Main.Point dt_a53j dt_a53k dt_a53l
}
}
}}]
Main.$WPoint
= \ (dt_a53g [Occ=Once!] :: Int)
(dt_a53h [Occ=Once!] :: Int)
(dt_a53i [Occ=Once!] :: Int) ->
case dt_a53g of { GHC.Types.I# dt_a53j [Occ=Once] ->
case dt_a53h of { GHC.Types.I# dt_a53k [Occ=Once] ->
case dt_a53i of { GHC.Types.I# dt_a53l [Occ=Once] ->
Main.Point dt_a53j dt_a53k dt_a53l
}
}
}
-- RHS size: {terms: 23, types: 16, coercions: 0, joins: 0/0}
Main.$WToken [InlPrag=INLINE[2]]
:: ByteString -> Point -> Point -> Token
[GblId[DataConWrapper],
Arity=3,
Caf=NoCafRefs,
Str=<S,U><S,U><S,U>m,
Unf=Unf{Src=InlineStable, TopLvl=True, Value=True, ConLike=True,
WorkFree=True, Expandable=True,
Guidance=ALWAYS_IF(arity=3,unsat_ok=True,boring_ok=False)
Tmpl= \ (dt_a58C [Occ=Once!] :: ByteString)
(dt_a58D [Occ=Once!] :: Point)
(dt_a58E [Occ=Once!] :: Point) ->
case dt_a58C of
{ Data.ByteString.Internal.PS dt_a58M [Occ=Once] dt_a58N [Occ=Once]
dt_a58O [Occ=Once] dt_a58P [Occ=Once] ->
case dt_a58D of
{ Point dt_a58Q [Occ=Once] dt_a58R [Occ=Once] dt_a58S [Occ=Once] ->
case dt_a58E of
{ Point dt_a58T [Occ=Once] dt_a58U [Occ=Once] dt_a58V [Occ=Once] ->
Main.Token
dt_a58M
dt_a58N
dt_a58O
dt_a58P
dt_a58Q
dt_a58R
dt_a58S
dt_a58T
dt_a58U
dt_a58V
}
}
}}]
Main.$WToken
= \ (dt_a58C [Occ=Once!] :: ByteString)
(dt_a58D [Occ=Once!] :: Point)
(dt_a58E [Occ=Once!] :: Point) ->
case dt_a58C of
{ Data.ByteString.Internal.PS dt_a58M [Occ=Once] dt_a58N [Occ=Once]
dt_a58O [Occ=Once] dt_a58P [Occ=Once] ->
case dt_a58D of
{ Point dt_a58Q [Occ=Once] dt_a58R [Occ=Once] dt_a58S [Occ=Once] ->
case dt_a58E of
{ Point dt_a58T [Occ=Once] dt_a58U [Occ=Once] dt_a58V [Occ=Once] ->
Main.Token
dt_a58M
dt_a58N
dt_a58O
dt_a58P
dt_a58Q
dt_a58R
dt_a58S
dt_a58T
dt_a58U
dt_a58V
}
}
}
-- RHS size: {terms: 1, types: 0, coercions: 0, joins: 0/0}
lvl_rcBv :: GHC.Prim.Addr#
[GblId, Caf=NoCafRefs]
lvl_rcBv
= "Pattern match failure in do expression at hask-tok3.hs:126:3-11"#
-- RHS size: {terms: 2, types: 0, coercions: 0, joins: 0/0}
lvl1_rcBw :: [Char]
[GblId]
lvl1_rcBw = GHC.CString.unpackCString# lvl_rcBv
-- RHS size: {terms: 5, types: 9, coercions: 10, joins: 0/0}
$wfail_rcBx
:: GHC.Prim.State# GHC.Prim.RealWorld
-> (# GHC.Prim.State# GHC.Prim.RealWorld, () #)
[GblId, Arity=1, Str=<S,U>]
$wfail_rcBx
= \ (w_sbD9 :: 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 :: *)))
@ ()
lvl1_rcBw)
`cast` (GHC.Types.N:IO[0] <()>_R
:: (IO () :: *)
~R# (GHC.Prim.State# GHC.Prim.RealWorld
-> (# GHC.Prim.State# GHC.Prim.RealWorld, () #) :: *)))
w_sbD9
-- RHS size: {terms: 2, types: 0, coercions: 0, joins: 0/0}
Main.$fShowPoint7 :: Int
[GblId,
Caf=NoCafRefs,
Str=m,
Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
WorkFree=True, Expandable=True, Guidance=IF_ARGS [] 10 20}]
Main.$fShowPoint7 = GHC.Types.I# 0#
Rec {
-- RHS size: {terms: 36, types: 39, coercions: 0, joins: 0/0}
$wgo_rcBy
:: forall b.
GHC.Prim.Addr#
-> GHC.Prim.Int#
-> GHC.Prim.State# GHC.Prim.RealWorld
-> (# GHC.Prim.State# GHC.Prim.RealWorld, Maybe Int #)
[GblId, Arity=3, Caf=NoCafRefs, Str=<L,U><S,U><S,U>]
$wgo_rcBy
= \ (@ b_sbDb)
(ww_sbDh :: GHC.Prim.Addr#)
(ww1_sbDl :: GHC.Prim.Int#)
(w_sbDe :: GHC.Prim.State# GHC.Prim.RealWorld) ->
case GHC.Prim.<# ww1_sbDl 0# of {
__DEFAULT ->
case GHC.Prim.readWord8OffAddr#
@ GHC.Prim.RealWorld
(GHC.Prim.plusAddr# ww_sbDh ww1_sbDl)
0#
w_sbDe
of
{ (# ipv2_i89p, ipv3_i89q #) ->
case ipv3_i89q of {
__DEFAULT ->
$wgo_rcBy @ b_sbDb ww_sbDh (GHC.Prim.-# ww1_sbDl 1#) ipv2_i89p;
10## ->
(# ipv2_i89p, GHC.Base.Just @ Int (GHC.Types.I# ww1_sbDl) #)
}
};
1# -> (# w_sbDe, GHC.Base.Nothing @ Int #)
}
end Rec }
-- RHS size: {terms: 383, types: 278, coercions: 8, joins: 8/15}
$w$sword'_rcBz
:: GHC.Prim.Addr#
-> GHC.ForeignPtr.ForeignPtrContents
-> GHC.Prim.Int#
-> GHC.Prim.Int#
-> GHC.Prim.Int#
-> GHC.Prim.Int#
-> GHC.Prim.Int#
-> Int
-> (# (Zepto.Result Token, Point), Int #)
[GblId, Arity=8, Str=<S,U><L,U><S,U><S,U><L,U><L,U><L,U><L,U>]
$w$sword'_rcBz
= \ (ww_sbEm :: GHC.Prim.Addr#)
(ww1_sbEn :: GHC.ForeignPtr.ForeignPtrContents)
(ww2_sbEo :: GHC.Prim.Int#)
(ww3_sbEp :: GHC.Prim.Int#)
(ww4_sbEt :: GHC.Prim.Int#)
(ww5_sbEu :: GHC.Prim.Int#)
(ww6_sbEv :: GHC.Prim.Int#)
(w_sbEj :: Int) ->
join {
$w$j1_sbE4 [InlPrag=NOUSERINLINE[0], Dmd=<C(C(S)),C(C1(U(U,U)))>]
:: GHC.Prim.State# GHC.Prim.RealWorld
-> GHC.Prim.Int# -> (# (Zepto.Result Token, Point), Int #)
[LclId[JoinId(2)], Arity=2, Str=<S,U><S,U>, Unf=OtherCon []]
$w$j1_sbE4 (w1_sbDY [OS=OneShot]
:: GHC.Prim.State# GHC.Prim.RealWorld)
(ww7_sbE2 [OS=OneShot] :: GHC.Prim.Int#)
= case GHC.Prim.touch#
@ 'GHC.Types.LiftedRep
@ GHC.ForeignPtr.ForeignPtrContents
ww1_sbEn
w1_sbDY
of
{ __DEFAULT ->
case {__pkg_ccall bytestring-0.10.8.2 Addr#
-> Word#
-> Word#
-> State# RealWorld
-> (# State# RealWorld, Word# #)}_a7Ta
(GHC.Prim.plusAddr# ww_sbEm ww2_sbEo)
(GHC.Prim.int2Word# ww7_sbE2)
10##
GHC.Prim.realWorld#
of
{ (# ds10_a7Tf, ds11_a7Tg #) ->
case GHC.Prim.touch#
@ 'GHC.Types.LiftedRep
@ GHC.ForeignPtr.ForeignPtrContents
ww1_sbEn
ds10_a7Tf
of
{ __DEFAULT ->
let {
ipv_s8dd [Dmd=<S,U>] :: GHC.Prim.Int#
[LclId]
ipv_s8dd = GHC.Prim.word2Int# ds11_a7Tg } in
join {
$j_savu [Dmd=<L,1*C1(C1(C1(C1(U(U,U)))))>]
:: GHC.Prim.Addr#
-> GHC.ForeignPtr.ForeignPtrContents
-> GHC.Prim.Int#
-> GHC.Prim.Int#
-> (# (Zepto.Result Token, Point), Int #)
[LclId[JoinId(4)],
Arity=4,
Str=<S,U><L,U><S,U><S,U>,
Unf=OtherCon []]
$j_savu (ipv1_s8dw [OS=OneShot] :: GHC.Prim.Addr#)
(ipv2_s8dx [OS=OneShot] :: GHC.ForeignPtr.ForeignPtrContents)
(ipv3_s8dy [OS=OneShot] :: GHC.Prim.Int#)
(ipv4_s8dz [OS=OneShot] :: GHC.Prim.Int#)
= join {
exit_X2R [Dmd=<L,C(U(U,U))>]
:: GHC.Prim.State# GHC.Prim.RealWorld
-> (# (Zepto.Result Token, Point), Int #)
[LclId[JoinId(1)], Arity=1, Str=<S,U>]
exit_X2R (w2_sbDK [OS=OneShot]
:: GHC.Prim.State# GHC.Prim.RealWorld)
= case GHC.Prim.touch#
@ 'GHC.Types.LiftedRep
@ GHC.ForeignPtr.ForeignPtrContents
ipv2_s8dx
w2_sbDK
of
{ __DEFAULT ->
let {
ipv5_s8dN :: GHC.Prim.Int#
[LclId]
ipv5_s8dN = GHC.Prim.+# ww4_sbEt ipv_s8dd } in
(# (Zepto.OK
@ Token
(Main.Token
ww_sbEm
ww1_sbEn
ww2_sbEo
ww7_sbE2
ww4_sbEt
ww5_sbEu
ww6_sbEv
ipv5_s8dN
ipv4_s8dz
ipv4_s8dz)
((Data.ByteString.Internal.PS
ww_sbEm
ww1_sbEn
(GHC.Prim.+# ww2_sbEo ww7_sbE2)
(GHC.Prim.-# ww3_sbEp ww7_sbE2))
`cast` (Sym (Zepto.N:S[0])
:: (ByteString :: *) ~R# (Zepto.S :: *))),
Main.Point ipv5_s8dN ipv4_s8dz ipv4_s8dz),
w_sbEj #)
} } in
joinrec {
$wgo1_sbDT [InlPrag=NOUSERINLINE[0], Occ=LoopBreaker]
:: GHC.Prim.Addr#
-> GHC.Prim.Int#
-> GHC.Prim.State# GHC.Prim.RealWorld
-> (# (Zepto.Result Token, Point), Int #)
[LclId[JoinId(3)], Arity=3, Str=<L,U><S,U><S,U>, Unf=OtherCon []]
$wgo1_sbDT (ww8_sbDN :: GHC.Prim.Addr#)
(ww9_sbDR :: GHC.Prim.Int#)
(w2_sbDK :: GHC.Prim.State# GHC.Prim.RealWorld)
= case GHC.Prim.>=# ww9_sbDR ipv4_s8dz of {
__DEFAULT ->
case GHC.Prim.readWord8OffAddr#
@ GHC.Prim.RealWorld ww8_sbDN 0# w2_sbDK
of
{ (# ipv5_i7Ul, ipv6_i7Um #) ->
case ipv6_i7Um of {
__DEFAULT ->
case GHC.Prim.touch#
@ 'GHC.Types.LiftedRep
@ GHC.ForeignPtr.ForeignPtrContents
ipv2_s8dx
ipv5_i7Ul
of
{ __DEFAULT ->
let {
ipv7_s8dN :: GHC.Prim.Int#
[LclId]
ipv7_s8dN = GHC.Prim.+# ww4_sbEt ipv_s8dd } in
(# (Zepto.OK
@ Token
(Main.Token
ww_sbEm
ww1_sbEn
ww2_sbEo
ww7_sbE2
ww4_sbEt
ww5_sbEu
ww6_sbEv
ipv7_s8dN
ipv4_s8dz
ww9_sbDR)
((Data.ByteString.Internal.PS
ww_sbEm
ww1_sbEn
(GHC.Prim.+# ww2_sbEo ww7_sbE2)
(GHC.Prim.-# ww3_sbEp ww7_sbE2))
`cast` (Sym (Zepto.N:S[0])
:: (ByteString :: *) ~R# (Zepto.S :: *))),
Main.Point ipv7_s8dN ipv4_s8dz ww9_sbDR),
w_sbEj #)
};
32## ->
jump $wgo1_sbDT
(GHC.Prim.plusAddr# ww8_sbDN 1#)
(GHC.Prim.+# ww9_sbDR 1#)
ipv5_i7Ul
}
};
1# -> jump exit_X2R w2_sbDK
}; } in
jump $wgo1_sbDT
(GHC.Prim.plusAddr# ipv1_s8dw ipv3_s8dy)
0#
GHC.Prim.realWorld# } in
case ipv_s8dd of wild_X4n {
__DEFAULT ->
case $wgo_rcBy
@ GHC.Types.Any
(GHC.Prim.plusAddr# ww_sbEm ww2_sbEo)
(GHC.Prim.-# ww7_sbE2 1#)
GHC.Prim.realWorld#
of
{ (# ipv1_i89C, ipv2_i89D #) ->
case GHC.Prim.touch#
@ 'GHC.Types.LiftedRep
@ GHC.ForeignPtr.ForeignPtrContents
ww1_sbEn
ipv1_i89C
of
{ __DEFAULT ->
case ipv2_i89D of {
Nothing -> jump $j_savu ww_sbEm ww1_sbEn ww2_sbEo ww7_sbE2;
Just a1_i88S ->
case a1_i88S of { GHC.Types.I# x_a8aI ->
let {
x1_i8aU [Dmd=<S,U>] :: GHC.Prim.Int#
[LclId]
x1_i8aU = GHC.Prim.+# x_a8aI 1# } in
case GHC.Prim.<=# x1_i8aU 0# of {
__DEFAULT ->
case GHC.Prim.>=# x1_i8aU ww7_sbE2 of {
__DEFAULT ->
let {
ipv3_s8dz [Dmd=<S,U>] :: GHC.Prim.Int#
[LclId]
ipv3_s8dz = GHC.Prim.-# ww7_sbE2 x1_i8aU } in
join {
exit_X31 [Dmd=<L,C(U(U,U))>]
:: GHC.Prim.State# GHC.Prim.RealWorld
-> (# (Zepto.Result Token, Point), Int #)
[LclId[JoinId(1)], Arity=1, Str=<S,U>]
exit_X31 (w2_sbDK [OS=OneShot]
:: GHC.Prim.State# GHC.Prim.RealWorld)
= case GHC.Prim.touch#
@ 'GHC.Types.LiftedRep
@ GHC.ForeignPtr.ForeignPtrContents
ww1_sbEn
w2_sbDK
of
{ __DEFAULT ->
let {
ipv4_s8dN :: GHC.Prim.Int#
[LclId]
ipv4_s8dN = GHC.Prim.+# ww4_sbEt wild_X4n } in
(# (Zepto.OK
@ Token
(Main.Token
ww_sbEm
ww1_sbEn
ww2_sbEo
ww7_sbE2
ww4_sbEt
ww5_sbEu
ww6_sbEv
ipv4_s8dN
ipv3_s8dz
ipv3_s8dz)
((Data.ByteString.Internal.PS
ww_sbEm
ww1_sbEn
(GHC.Prim.+# ww2_sbEo ww7_sbE2)
(GHC.Prim.-# ww3_sbEp ww7_sbE2))
`cast` (Sym (Zepto.N:S[0])
:: (ByteString :: *) ~R# (Zepto.S :: *))),
Main.Point ipv4_s8dN ipv3_s8dz ipv3_s8dz),
w_sbEj #)
} } in
joinrec {
$wgo1_sbDT [InlPrag=NOUSERINLINE[0], Occ=LoopBreaker]
:: GHC.Prim.Addr#
-> GHC.Prim.Int#
-> GHC.Prim.State# GHC.Prim.RealWorld
-> (# (Zepto.Result Token, Point), Int #)
[LclId[JoinId(3)], Arity=3, Str=<L,U><S,U><S,U>, Unf=OtherCon []]
$wgo1_sbDT (ww8_sbDN :: GHC.Prim.Addr#)
(ww9_sbDR :: GHC.Prim.Int#)
(w2_sbDK :: GHC.Prim.State# GHC.Prim.RealWorld)
= case GHC.Prim.>=# ww9_sbDR ipv3_s8dz of {
__DEFAULT ->
case GHC.Prim.readWord8OffAddr#
@ GHC.Prim.RealWorld ww8_sbDN 0# w2_sbDK
of
{ (# ipv4_i7Ul, ipv5_i7Um #) ->
case ipv5_i7Um of {
__DEFAULT ->
case GHC.Prim.touch#
@ 'GHC.Types.LiftedRep
@ GHC.ForeignPtr.ForeignPtrContents
ww1_sbEn
ipv4_i7Ul
of
{ __DEFAULT ->
let {
ipv6_s8dN :: GHC.Prim.Int#
[LclId]
ipv6_s8dN = GHC.Prim.+# ww4_sbEt wild_X4n } in
(# (Zepto.OK
@ Token
(Main.Token
ww_sbEm
ww1_sbEn
ww2_sbEo
ww7_sbE2
ww4_sbEt
ww5_sbEu
ww6_sbEv
ipv6_s8dN
ipv3_s8dz
ww9_sbDR)
((Data.ByteString.Internal.PS
ww_sbEm
ww1_sbEn
(GHC.Prim.+# ww2_sbEo ww7_sbE2)
(GHC.Prim.-# ww3_sbEp ww7_sbE2))
`cast` (Sym (Zepto.N:S[0])
:: (ByteString :: *) ~R# (Zepto.S :: *))),
Main.Point ipv6_s8dN ipv3_s8dz ww9_sbDR),
w_sbEj #)
};
32## ->
jump $wgo1_sbDT
(GHC.Prim.plusAddr# ww8_sbDN 1#)
(GHC.Prim.+# ww9_sbDR 1#)
ipv4_i7Ul
}
};
1# -> jump exit_X31 w2_sbDK
}; } in
jump $wgo1_sbDT
(GHC.Prim.plusAddr# ww_sbEm (GHC.Prim.+# ww2_sbEo x1_i8aU))
0#
GHC.Prim.realWorld#;
1# ->
jump $j_savu
__NULL Data.ByteString.Internal.$fMonoidByteString1 0# 0#
};
1# -> jump $j_savu ww_sbEm ww1_sbEn ww2_sbEo ww7_sbE2
}
}
}
}
};
0# -> jump $j_savu ww_sbEm ww1_sbEn ww2_sbEo ww7_sbE2
}
}
}
} } in
join {
exit_X2F [Dmd=<L,C(U(U,U))>]
:: GHC.Prim.State# GHC.Prim.RealWorld
-> (# (Zepto.Result Token, Point), Int #)
[LclId[JoinId(1)], Arity=1, Str=<S,U>]
exit_X2F (w1_sbE7 [OS=OneShot]
:: GHC.Prim.State# GHC.Prim.RealWorld)
= jump $w$j1_sbE4 w1_sbE7 ww3_sbEp } in
joinrec {
$wgo1_sbEg [InlPrag=NOUSERINLINE[0], Occ=LoopBreaker]
:: GHC.Prim.Addr#
-> GHC.Prim.Int#
-> GHC.Prim.State# GHC.Prim.RealWorld
-> (# (Zepto.Result Token, Point), Int #)
[LclId[JoinId(3)], Arity=3, Str=<L,U><S,U><S,U>, Unf=OtherCon []]
$wgo1_sbEg (ww7_sbEa :: GHC.Prim.Addr#)
(ww8_sbEe :: GHC.Prim.Int#)
(w1_sbE7 :: GHC.Prim.State# GHC.Prim.RealWorld)
= case GHC.Prim.>=# ww8_sbEe ww3_sbEp of {
__DEFAULT ->
case GHC.Prim.readWord8OffAddr#
@ GHC.Prim.RealWorld ww7_sbEa 0# w1_sbE7
of
{ (# ipv2_i8co, ipv3_i8cp #) ->
case ipv3_i8cp of {
__DEFAULT ->
jump $wgo1_sbEg
(GHC.Prim.plusAddr# ww7_sbEa 1#)
(GHC.Prim.+# ww8_sbEe 1#)
ipv2_i8co;
10## -> jump $w$j1_sbE4 ipv2_i8co ww8_sbEe;
13## -> jump $w$j1_sbE4 ipv2_i8co ww8_sbEe;
32## -> jump $w$j1_sbE4 ipv2_i8co ww8_sbEe
}
};
1# -> jump exit_X2F w1_sbE7
}; } in
jump $wgo1_sbEg
(GHC.Prim.plusAddr# ww_sbEm ww2_sbEo) 0# GHC.Prim.realWorld#
Rec {
-- RHS size: {terms: 24, types: 26, coercions: 22, joins: 0/0}
$wsimple_count_rcBB
:: GHC.Prim.Addr#
-> GHC.ForeignPtr.ForeignPtrContents
-> GHC.Prim.Int#
-> GHC.Prim.Int#
-> GHC.Prim.Int#
-> GHC.Prim.Int#
-> GHC.Prim.Int#
-> Int
-> (# (Zepto.Result (), Point), Int #)
[GblId, Arity=8, Str=<S,U><L,U><S,U><S,U><S,U><S,U><S,U><L,U>]
$wsimple_count_rcBB
= \ (ww_sbEG :: GHC.Prim.Addr#)
(ww1_sbEH :: GHC.ForeignPtr.ForeignPtrContents)
(ww2_sbEI :: GHC.Prim.Int#)
(ww3_sbEJ :: GHC.Prim.Int#)
(ww4_sbEN :: GHC.Prim.Int#)
(ww5_sbEO :: GHC.Prim.Int#)
(ww6_sbEP :: GHC.Prim.Int#)
(w_sbED :: Int) ->
case (((((simple_count1_rcBF
((Data.ByteString.Internal.PS ww_sbEG ww1_sbEH ww2_sbEI ww3_sbEJ)
`cast` (Sym (Zepto.N:S[0])
:: (ByteString :: *) ~R# (Zepto.S :: *))))
`cast` (Control.Monad.Trans.State.Strict.N:StateT[0]
<Point>_N <State Int>_R <Zepto.Result ()>_N
:: (StateT Point (State Int) (Zepto.Result ()) :: *)
~R# (Point -> State Int (Zepto.Result (), Point) :: *)))
(Main.Point ww4_sbEN ww5_sbEO ww6_sbEP))
`cast` (Control.Monad.Trans.State.Strict.N:StateT[0]
<Int>_N <Identity>_R <(Zepto.Result (), Point)>_N
:: (StateT Int Identity (Zepto.Result (), Point) :: *)
~R# (Int -> Identity ((Zepto.Result (), Point), Int) :: *)))
w_sbED)
`cast` (Data.Functor.Identity.N:Identity[0]
<((Zepto.Result (), Point), Int)>_R
:: (Identity ((Zepto.Result (), Point), Int) :: *)
~R# (((Zepto.Result (), Point), Int) :: *))
of
{ (ww8_sbKB, ww9_sbKC) ->
(# ww8_sbKB, ww9_sbKC #)
}
-- RHS size: {terms: 57, types: 67, coercions: 1, joins: 0/0}
$w$j_rcBC
:: Zepto.Result (Token, Bool)
-> Point -> Int -> (# (Zepto.Result (), Point), Int #)
[GblId, Arity=3, Str=<S,1*U><L,U(U,U,U)><L,U(U)>]
$w$j_rcBC
= \ (ww_sbEZ [OS=OneShot] :: Zepto.Result (Token, Bool))
(ww1_sbF0 [OS=OneShot] :: Point)
(w_sbEW [OS=OneShot] :: Int) ->
case ww_sbEZ of {
Zepto.Fail err_i83f ->
(# (Zepto.Fail @ () err_i83f, ww1_sbF0), w_sbEW #);
Zepto.OK a1_i83i s'_i83j ->
case a1_i83i of { (ds_sc56, end1_sc57) ->
case ds_sc56 of
{ Token dt_d7UZ dt1_d7V0 dt2_d7V1 dt3_d7V2 dt4_d7V3 dt5_d7V4
dt6_d7V5 dt7_d7V6 dt8_d7V7 dt9_d7V8 ->
case end1_sc57 of {
False ->
case s'_i83j
`cast` (Zepto.N:S[0] :: (Zepto.S :: *) ~R# (ByteString :: *))
of
{ Data.ByteString.Internal.PS ww3_sbEG ww4_sbEH ww5_sbEI
ww6_sbEJ ->
case ww1_sbF0 of { Point ww8_sbEN ww9_sbEO ww10_sbEP ->
$wsimple_count_rcBB
ww3_sbEG
ww4_sbEH
ww5_sbEI
ww6_sbEJ
ww8_sbEN
ww9_sbEO
ww10_sbEP
(case w_sbEW of { GHC.Types.I# x_a8aI ->
GHC.Types.I# (GHC.Prim.+# x_a8aI 1#)
})
}
};
True ->
(# (Zepto.OK @ () GHC.Tuple.() s'_i83j, ww1_sbF0),
case w_sbEW of { GHC.Types.I# x_a8aI ->
GHC.Types.I# (GHC.Prim.+# x_a8aI 1#)
} #)
}
}
}
}
-- RHS size: {terms: 145, types: 126, coercions: 5, joins: 3/4}
$wsimple_count1_rcBD
:: GHC.Prim.Addr#
-> GHC.ForeignPtr.ForeignPtrContents
-> GHC.Prim.Int#
-> GHC.Prim.Int#
-> GHC.Prim.Int#
-> GHC.Prim.Int#
-> GHC.Prim.Int#
-> Int
-> (# (Zepto.Result (), Point), Int #)
[GblId, Arity=8, Str=<S,U><L,U><S,U><S,U><S,U><S,U><S,U><L,U>]
$wsimple_count1_rcBD
= \ (ww_sbFH :: GHC.Prim.Addr#)
(ww1_sbFI :: GHC.ForeignPtr.ForeignPtrContents)
(ww2_sbFJ :: GHC.Prim.Int#)
(ww3_sbFK :: GHC.Prim.Int#)
(ww4_sbFO :: GHC.Prim.Int#)
(ww5_sbFP :: GHC.Prim.Int#)
(ww6_sbFQ :: GHC.Prim.Int#)
(w_sbFE :: Int) ->
case $w$sword'_rcBz
ww_sbFH
ww1_sbFI
ww2_sbFJ
ww3_sbFK
ww4_sbFO
ww5_sbFP
ww6_sbFQ
w_sbFE
of
{ (# ww8_sbKy, ww9_sbKz #) ->
case ww8_sbKy of { (a1_X88g, s'_X88i) ->
case a1_X88g of {
Zepto.Fail err_i83I ->
(# (Zepto.Fail @ () err_i83I, s'_X88i), ww9_sbKz #);
Zepto.OK a2_i83L s'1_i83M ->
case s'1_i83M
`cast` (Zepto.N:S[0] :: (Zepto.S :: *) ~R# (ByteString :: *))
of
{ Data.ByteString.Internal.PS dt_iaXP dt1_iaXQ dt2_iaXR dt3_iaXS ->
join {
exit_X30 [Dmd=<L,C(C1(U(U,U)))>]
:: GHC.Prim.Int#
-> GHC.Prim.State# GHC.Prim.RealWorld
-> (# (Zepto.Result (), Point), Int #)
[LclId[JoinId(2)], Arity=2, Str=<S,U><S,U>]
exit_X30 (ww10_sbFr [OS=OneShot] :: GHC.Prim.Int#)
(ipv2_i8co [OS=OneShot] :: GHC.Prim.State# GHC.Prim.RealWorld)
= case GHC.Prim.touch#
@ 'GHC.Types.LiftedRep
@ GHC.ForeignPtr.ForeignPtrContents
dt1_iaXQ
ipv2_i8co
of
{ __DEFAULT ->
let {
s'3_sc6L [Dmd=<S,U>] :: GHC.Prim.Int#
[LclId]
s'3_sc6L = GHC.Prim.-# dt3_iaXS ww10_sbFr } in
case GHC.Prim.tagToEnum# @ Bool (GHC.Prim.<=# s'3_sc6L 0#)
of vx_i7UX
{ __DEFAULT ->
$w$j_rcBC
(Zepto.OK
@ (Token, Bool)
(a2_i83L, vx_i7UX)
((Data.ByteString.Internal.PS
dt_iaXP dt1_iaXQ (GHC.Prim.+# dt2_iaXR ww10_sbFr) s'3_sc6L)
`cast` (Sym (Zepto.N:S[0])
:: (ByteString :: *) ~R# (Zepto.S :: *))))
s'_X88i
ww9_sbKz
}
} } in
join {
exit1_X2X [Dmd=<L,C(U(U,U))>]
:: GHC.Prim.State# GHC.Prim.RealWorld
-> (# (Zepto.Result (), Point), Int #)
[LclId[JoinId(1)], Arity=1, Str=<S,U>]
exit1_X2X (w1_sbFk [OS=OneShot]
:: GHC.Prim.State# GHC.Prim.RealWorld)
= case GHC.Prim.touch#
@ 'GHC.Types.LiftedRep
@ GHC.ForeignPtr.ForeignPtrContents
dt1_iaXQ
w1_sbFk
of
{ __DEFAULT ->
$w$j_rcBC
(Zepto.OK
@ (Token, Bool)
(a2_i83L, GHC.Types.True)
((Data.ByteString.Internal.PS
dt_iaXP dt1_iaXQ (GHC.Prim.+# dt2_iaXR dt3_iaXS) 0#)
`cast` (Sym (Zepto.N:S[0])
:: (ByteString :: *) ~R# (Zepto.S :: *))))
s'_X88i
ww9_sbKz
} } in
joinrec {
$wgo1_sbFt [InlPrag=NOUSERINLINE[0], Occ=LoopBreaker]
:: GHC.Prim.Addr#
-> GHC.Prim.Int#
-> GHC.Prim.State# GHC.Prim.RealWorld
-> (# (Zepto.Result (), Point), Int #)
[LclId[JoinId(3)], Arity=3, Str=<L,U><S,U><S,U>, Unf=OtherCon []]
$wgo1_sbFt (ww10_sbFn :: GHC.Prim.Addr#)
(ww11_sbFr :: GHC.Prim.Int#)
(w1_sbFk :: GHC.Prim.State# GHC.Prim.RealWorld)
= case GHC.Prim.>=# ww11_sbFr dt3_iaXS of {
__DEFAULT ->
case GHC.Prim.readWord8OffAddr#
@ GHC.Prim.RealWorld ww10_sbFn 0# w1_sbFk
of
{ (# ipv2_i8co, ipv3_i8cp #) ->
case ipv3_i8cp of {
__DEFAULT -> jump exit_X30 ww11_sbFr ipv2_i8co;
10## ->
jump $wgo1_sbFt
(GHC.Prim.plusAddr# ww10_sbFn 1#)
(GHC.Prim.+# ww11_sbFr 1#)
ipv2_i8co;
13## ->
jump $wgo1_sbFt
(GHC.Prim.plusAddr# ww10_sbFn 1#)
(GHC.Prim.+# ww11_sbFr 1#)
ipv2_i8co;
32## ->
jump $wgo1_sbFt
(GHC.Prim.plusAddr# ww10_sbFn 1#)
(GHC.Prim.+# ww11_sbFr 1#)
ipv2_i8co
}
};
1# -> jump exit1_X2X w1_sbFk
}; } in
jump $wgo1_sbFt
(GHC.Prim.plusAddr# dt_iaXP dt2_iaXR) 0# GHC.Prim.realWorld#
}
}
}
}
-- RHS size: {terms: 23, types: 30, coercions: 9, joins: 0/0}
simple_count_rcBE
:: Zepto.S
-> Point -> Int -> Identity ((Zepto.Result (), Point), Int)
[GblId,
Arity=3,
Str=<S(SLSS),1*U(U,U,U,U)><S(SSS),1*U(U,U,U)><L,U>m]
simple_count_rcBE
= \ (w_sbFC :: Zepto.S) (w1_sbFD :: Point) (w2_sbFE :: Int) ->
case w_sbFC
`cast` (Zepto.N:S[0] :: (Zepto.S :: *) ~R# (ByteString :: *))
of
{ Data.ByteString.Internal.PS ww1_sbFH ww2_sbFI ww3_sbFJ
ww4_sbFK ->
case w1_sbFD of { Point ww6_sbFO ww7_sbFP ww8_sbFQ ->
case $wsimple_count1_rcBD
ww1_sbFH
ww2_sbFI
ww3_sbFJ
ww4_sbFK
ww6_sbFO
ww7_sbFP
ww8_sbFQ
w2_sbFE
of
{ (# ww10_sbKE, ww11_sbKF #) ->
(ww10_sbKE, ww11_sbKF)
`cast` (Sym (Data.Functor.Identity.N:Identity[0]
<((Zepto.Result (), Point), Int)>_R)
:: (((Zepto.Result (), Point), Int) :: *)
~R# (Identity ((Zepto.Result (), Point), Int) :: *))
}
}
}
-- RHS size: {terms: 1, types: 0, coercions: 21, joins: 0/0}
simple_count1_rcBF
:: Zepto.S -> StateT Point (StateT Int Identity) (Zepto.Result ())
[GblId,
Arity=3,
Str=<S(SLSS),1*U(U,U,U,U)><S(SSS),1*U(U,U,U)><L,U>m]
simple_count1_rcBF
= simple_count_rcBE
`cast` (<Zepto.S>_R
->_R (<Point>_R
->_R Sym (Control.Monad.Trans.State.Strict.N:StateT[0]
<Int>_N
<Identity>_R
<(Zepto.Result (),
Point)>_N)) ; Sym (Control.Monad.Trans.State.Strict.N:StateT[0]
<Point>_N
<StateT Int Identity>_R
<Zepto.Result ()>_N)
:: (Zepto.S
-> Point -> Int -> Identity ((Zepto.Result (), Point), Int) :: *)
~R# (Zepto.S
-> StateT Point (StateT Int Identity) (Zepto.Result ()) :: *))
end Rec }
Rec {
-- RHS size: {terms: 325, types: 236, coercions: 2, joins: 10/15}
$w$ssimple__rcBG
:: GHC.Prim.Addr#
-> GHC.ForeignPtr.ForeignPtrContents
-> GHC.Prim.Int#
-> GHC.Prim.Int#
-> GHC.Prim.Int#
-> (# Zepto.Result (), Point #)
[GblId, Arity=5, Str=<S,U><L,U><S,U><S,U><L,U>]
$w$ssimple__rcBG
= \ (ww_sbHc :: GHC.Prim.Addr#)
(ww1_sbHd :: GHC.ForeignPtr.ForeignPtrContents)
(ww2_sbHe :: GHC.Prim.Int#)
(ww3_sbHf :: GHC.Prim.Int#)
(ww4_sbHj :: GHC.Prim.Int#) ->
join {
$w$j1_sbGV [InlPrag=NOUSERINLINE[0], Dmd=<C(C(S)),C(C1(U(U,U)))>]
:: GHC.Prim.State# GHC.Prim.RealWorld
-> GHC.Prim.Int# -> (# Zepto.Result (), Point #)
[LclId[JoinId(2)], Arity=2, Str=<S,U><S,U>, Unf=OtherCon []]
$w$j1_sbGV (w_sbGP [OS=OneShot]
:: GHC.Prim.State# GHC.Prim.RealWorld)
(ww5_sbGT [OS=OneShot] :: GHC.Prim.Int#)
= case GHC.Prim.touch#
@ 'GHC.Types.LiftedRep
@ GHC.ForeignPtr.ForeignPtrContents
ww1_sbHd
w_sbGP
of
{ __DEFAULT ->
case {__pkg_ccall bytestring-0.10.8.2 Addr#
-> Word#
-> Word#
-> State# RealWorld
-> (# State# RealWorld, Word# #)}_a7Ta
(GHC.Prim.plusAddr# ww_sbHc ww2_sbHe)
(GHC.Prim.int2Word# ww5_sbGT)
10##
GHC.Prim.realWorld#
of
{ (# ds10_a7Tf, ds11_a7Tg #) ->
case GHC.Prim.touch#
@ 'GHC.Types.LiftedRep
@ GHC.ForeignPtr.ForeignPtrContents
ww1_sbHd
ds10_a7Tf
of
{ __DEFAULT ->
let {
ipv_s8dd [Dmd=<S,U>] :: GHC.Prim.Int#
[LclId]
ipv_s8dd = GHC.Prim.word2Int# ds11_a7Tg } in
join {
$j_sauy [Dmd=<L,1*C1(C1(C1(C1(U(U,U)))))>]
:: GHC.Prim.Addr#
-> GHC.ForeignPtr.ForeignPtrContents
-> GHC.Prim.Int#
-> GHC.Prim.Int#
-> (# Zepto.Result (), Point #)
[LclId[JoinId(4)],
Arity=4,
Str=<S,U><L,U><S,U><S,U>,
Unf=OtherCon []]
$j_sauy (ipv1_s8dw [OS=OneShot] :: GHC.Prim.Addr#)
(ipv2_s8dx [OS=OneShot] :: GHC.ForeignPtr.ForeignPtrContents)
(ipv3_s8dy [OS=OneShot] :: GHC.Prim.Int#)
(ipv4_s8dz [OS=OneShot] :: GHC.Prim.Int#)
= join {
$w$j2_sbGy [InlPrag=NOUSERINLINE[0], Dmd=<C(C(S)),C(C1(U(U,U)))>]
:: GHC.Prim.State# GHC.Prim.RealWorld
-> GHC.Prim.Int# -> (# Zepto.Result (), Point #)
[LclId[JoinId(2)], Arity=2, Str=<S,U><L,U>, Unf=OtherCon []]
$w$j2_sbGy (w1_sbGs [OS=OneShot]
:: GHC.Prim.State# GHC.Prim.RealWorld)
(ww6_sbGw [OS=OneShot] :: GHC.Prim.Int#)
= case GHC.Prim.touch#
@ 'GHC.Types.LiftedRep
@ GHC.ForeignPtr.ForeignPtrContents
ipv2_s8dx
w1_sbGs
of
{ __DEFAULT ->
let {
ps_sb03 [Dmd=<S,U>] :: GHC.Prim.Int#
[LclId]
ps_sb03 = GHC.Prim.+# ww2_sbHe ww5_sbGT } in
let {
ps1_sb04 [Dmd=<S,U>] :: GHC.Prim.Int#
[LclId]
ps1_sb04 = GHC.Prim.-# ww3_sbHf ww5_sbGT } in
join {
$w$j3_sbGf [InlPrag=NOUSERINLINE[0], Dmd=<C(C(S)),C(C1(U(U,U)))>]
:: GHC.Prim.State# GHC.Prim.RealWorld
-> GHC.Prim.Int# -> (# Zepto.Result (), Point #)
[LclId[JoinId(2)], Arity=2, Str=<S,U><S,U>, Unf=OtherCon []]
$w$j3_sbGf (w2_sbG9 [OS=OneShot]
:: GHC.Prim.State# GHC.Prim.RealWorld)
(ww7_sbGd [OS=OneShot] :: GHC.Prim.Int#)
= case GHC.Prim.touch#
@ 'GHC.Types.LiftedRep
@ GHC.ForeignPtr.ForeignPtrContents
ww1_sbHd
w2_sbG9
of
{ __DEFAULT ->
let {
s'4_sb0j [Dmd=<S,U>] :: GHC.Prim.Int#
[LclId]
s'4_sb0j = GHC.Prim.-# ps1_sb04 ww7_sbGd } in
case GHC.Prim.<=# s'4_sb0j 0# of {
__DEFAULT ->
$w$ssimple__rcBG
ww_sbHc
ww1_sbHd
(GHC.Prim.+# ps_sb03 ww7_sbGd)
s'4_sb0j
(GHC.Prim.+# ww4_sbHj ipv_s8dd);
1# ->
(# Zepto.OK
@ ()
GHC.Tuple.()
((Data.ByteString.Internal.PS
ww_sbHc ww1_sbHd (GHC.Prim.+# ps_sb03 ww7_sbGd) s'4_sb0j)
`cast` (Sym (Zepto.N:S[0])
:: (ByteString :: *) ~R# (Zepto.S :: *))),
Main.Point
(GHC.Prim.+# ww4_sbHj ipv_s8dd) ipv4_s8dz ww6_sbGw #)
}
} } in
join {
exit_X2T [Dmd=<L,C(U(U,U))>]
:: GHC.Prim.State# GHC.Prim.RealWorld
-> (# Zepto.Result (), Point #)
[LclId[JoinId(1)], Arity=1, Str=<S,U>]
exit_X2T (w2_sbGi [OS=OneShot]
:: GHC.Prim.State# GHC.Prim.RealWorld)
= jump $w$j3_sbGf w2_sbGi ps1_sb04 } in
joinrec {
$wgo1_sbGr [InlPrag=NOUSERINLINE[0], Occ=LoopBreaker]
:: GHC.Prim.Addr#
-> GHC.Prim.Int#
-> GHC.Prim.State# GHC.Prim.RealWorld
-> (# Zepto.Result (), Point #)
[LclId[JoinId(3)], Arity=3, Str=<L,U><S,U><S,U>, Unf=OtherCon []]
$wgo1_sbGr (ww7_sbGl :: GHC.Prim.Addr#)
(ww8_sbGp :: GHC.Prim.Int#)
(w2_sbGi :: GHC.Prim.State# GHC.Prim.RealWorld)
= case GHC.Prim.>=# ww8_sbGp ps1_sb04 of {
__DEFAULT ->
case GHC.Prim.readWord8OffAddr#
@ GHC.Prim.RealWorld ww7_sbGl 0# w2_sbGi
of
{ (# ipv5_i8co, ipv6_i8cp #) ->
case ipv6_i8cp of {
__DEFAULT -> jump $w$j3_sbGf ipv5_i8co ww8_sbGp;
10## ->
jump $wgo1_sbGr
(GHC.Prim.plusAddr# ww7_sbGl 1#)
(GHC.Prim.+# ww8_sbGp 1#)
ipv5_i8co;
13## ->
jump $wgo1_sbGr
(GHC.Prim.plusAddr# ww7_sbGl 1#)
(GHC.Prim.+# ww8_sbGp 1#)
ipv5_i8co;
32## ->
jump $wgo1_sbGr
(GHC.Prim.plusAddr# ww7_sbGl 1#)
(GHC.Prim.+# ww8_sbGp 1#)
ipv5_i8co
}
};
1# -> jump exit_X2T w2_sbGi
}; } in
jump $wgo1_sbGr
(GHC.Prim.plusAddr# ww_sbHc ps_sb03) 0# GHC.Prim.realWorld#
} } in
join {
exit_X2O [Dmd=<L,C(U(U,U))>]
:: GHC.Prim.State# GHC.Prim.RealWorld
-> (# Zepto.Result (), Point #)
[LclId[JoinId(1)], Arity=1, Str=<S,U>]
exit_X2O (w1_sbGB [OS=OneShot]
:: GHC.Prim.State# GHC.Prim.RealWorld)
= jump $w$j2_sbGy w1_sbGB ipv4_s8dz } in
joinrec {
$wgo1_sbGK [InlPrag=NOUSERINLINE[0], Occ=LoopBreaker]
:: GHC.Prim.Addr#
-> GHC.Prim.Int#
-> GHC.Prim.State# GHC.Prim.RealWorld
-> (# Zepto.Result (), Point #)
[LclId[JoinId(3)], Arity=3, Str=<L,U><S,U><S,U>, Unf=OtherCon []]
$wgo1_sbGK (ww6_sbGE :: GHC.Prim.Addr#)
(ww7_sbGI :: GHC.Prim.Int#)
(w1_sbGB :: GHC.Prim.State# GHC.Prim.RealWorld)
= case GHC.Prim.>=# ww7_sbGI ipv4_s8dz of {
__DEFAULT ->
case GHC.Prim.readWord8OffAddr#
@ GHC.Prim.RealWorld ww6_sbGE 0# w1_sbGB
of
{ (# ipv5_i7Ul, ipv6_i7Um #) ->
case ipv6_i7Um of {
__DEFAULT -> jump $w$j2_sbGy ipv5_i7Ul ww7_sbGI;
32## ->
jump $wgo1_sbGK
(GHC.Prim.plusAddr# ww6_sbGE 1#)
(GHC.Prim.+# ww7_sbGI 1#)
ipv5_i7Ul
}
};
1# -> jump exit_X2O w1_sbGB
}; } in
jump $wgo1_sbGK
(GHC.Prim.plusAddr# ipv1_s8dw ipv3_s8dy)
0#
GHC.Prim.realWorld# } in
case ipv_s8dd of {
__DEFAULT ->
case $wgo_rcBy
@ GHC.Types.Any
(GHC.Prim.plusAddr# ww_sbHc ww2_sbHe)
(GHC.Prim.-# ww5_sbGT 1#)
GHC.Prim.realWorld#
of
{ (# ipv1_i89C, ipv2_i89D #) ->
case GHC.Prim.touch#
@ 'GHC.Types.LiftedRep
@ GHC.ForeignPtr.ForeignPtrContents
ww1_sbHd
ipv1_i89C
of
{ __DEFAULT ->
case ipv2_i89D of {
Nothing -> jump $j_sauy ww_sbHc ww1_sbHd ww2_sbHe ww5_sbGT;
Just a1_i88S ->
case a1_i88S of { GHC.Types.I# x_a8aI ->
let {
x1_i8aU [Dmd=<S,U>] :: GHC.Prim.Int#
[LclId]
x1_i8aU = GHC.Prim.+# x_a8aI 1# } in
case GHC.Prim.<=# x1_i8aU 0# of {
__DEFAULT ->
case GHC.Prim.>=# x1_i8aU ww5_sbGT of {
__DEFAULT ->
jump $j_sauy
ww_sbHc
ww1_sbHd
(GHC.Prim.+# ww2_sbHe x1_i8aU)
(GHC.Prim.-# ww5_sbGT x1_i8aU);
1# ->
jump $j_sauy
__NULL Data.ByteString.Internal.$fMonoidByteString1 0# 0#
};
1# -> jump $j_sauy ww_sbHc ww1_sbHd ww2_sbHe ww5_sbGT
}
}
}
}
};
0# -> jump $j_sauy ww_sbHc ww1_sbHd ww2_sbHe ww5_sbGT
}
}
}
} } in
join {
exit_X2C [Dmd=<L,C(U(U,U))>]
:: GHC.Prim.State# GHC.Prim.RealWorld
-> (# Zepto.Result (), Point #)
[LclId[JoinId(1)], Arity=1, Str=<S,U>]
exit_X2C (w_sbGY [OS=OneShot]
:: GHC.Prim.State# GHC.Prim.RealWorld)
= jump $w$j1_sbGV w_sbGY ww3_sbHf } in
joinrec {
$wgo1_sbH7 [InlPrag=NOUSERINLINE[0], Occ=LoopBreaker]
:: GHC.Prim.Addr#
-> GHC.Prim.Int#
-> GHC.Prim.State# GHC.Prim.RealWorld
-> (# Zepto.Result (), Point #)
[LclId[JoinId(3)], Arity=3, Str=<L,U><S,U><S,U>, Unf=OtherCon []]
$wgo1_sbH7 (ww5_sbH1 :: GHC.Prim.Addr#)
(ww6_sbH5 :: GHC.Prim.Int#)
(w_sbGY :: GHC.Prim.State# GHC.Prim.RealWorld)
= case GHC.Prim.>=# ww6_sbH5 ww3_sbHf of {
__DEFAULT ->
case GHC.Prim.readWord8OffAddr#
@ GHC.Prim.RealWorld ww5_sbH1 0# w_sbGY
of
{ (# ipv2_i8co, ipv3_i8cp #) ->
case ipv3_i8cp of {
__DEFAULT ->
jump $wgo1_sbH7
(GHC.Prim.plusAddr# ww5_sbH1 1#)
(GHC.Prim.+# ww6_sbH5 1#)
ipv2_i8co;
10## -> jump $w$j1_sbGV ipv2_i8co ww6_sbH5;
13## -> jump $w$j1_sbGV ipv2_i8co ww6_sbH5;
32## -> jump $w$j1_sbGV ipv2_i8co ww6_sbH5
}
};
1# -> jump exit_X2C w_sbGY
}; } in
jump $wgo1_sbH7
(GHC.Prim.plusAddr# ww_sbHc ww2_sbHe) 0# GHC.Prim.realWorld#
end Rec }
-- RHS size: {terms: 1, types: 0, coercions: 0, joins: 0/0}
f_rcBH :: GHC.Prim.Addr#
[GblId, Caf=NoCafRefs]
f_rcBH = "Token {"#
-- RHS size: {terms: 2, types: 0, coercions: 0, joins: 0/0}
f1_rcBI :: [Char]
[GblId]
f1_rcBI = GHC.CString.unpackCString# f_rcBH
-- RHS size: {terms: 1, types: 0, coercions: 0, joins: 0/0}
Main.$fShowPoint6 :: GHC.Prim.Addr#
[GblId,
Caf=NoCafRefs,
Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
WorkFree=True, Expandable=True, Guidance=IF_ARGS [] 30 0}]
Main.$fShowPoint6 = "Point {"#
-- RHS size: {terms: 1, types: 0, coercions: 0, joins: 0/0}
Main.$fShowPoint5 :: GHC.Prim.Addr#
[GblId,
Caf=NoCafRefs,
Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
WorkFree=True, Expandable=True, Guidance=IF_ARGS [] 30 0}]
Main.$fShowPoint5 = "line = "#
-- RHS size: {terms: 1, types: 0, coercions: 0, joins: 0/0}
Main.$fShowPoint4 :: GHC.Prim.Addr#
[GblId,
Caf=NoCafRefs,
Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
WorkFree=True, Expandable=True, Guidance=IF_ARGS [] 40 0}]
Main.$fShowPoint4 = "column = "#
-- RHS size: {terms: 1, types: 0, coercions: 0, joins: 0/0}
Main.$fShowPoint3 :: GHC.Prim.Addr#
[GblId,
Caf=NoCafRefs,
Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
WorkFree=True, Expandable=True, Guidance=IF_ARGS [] 50 0}]
Main.$fShowPoint3 = "indentation = "#
-- RHS size: {terms: 1, types: 0, coercions: 0, joins: 0/0}
Main.$fShowPoint2 :: 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.$fShowPoint2 = "}"#
-- RHS size: {terms: 60, types: 42, coercions: 0, joins: 0/1}
Main.$w$cshowsPrec [InlPrag=NOUSERINLINE[0]]
:: GHC.Prim.Int#
-> GHC.Prim.Int#
-> GHC.Prim.Int#
-> GHC.Prim.Int#
-> String
-> String
[GblId,
Arity=5,
Str=<S,U><L,U><L,U><L,U><L,U>,
Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
WorkFree=True, Expandable=True,
Guidance=IF_ARGS [0 0 0 0 0] 491 30}]
Main.$w$cshowsPrec
= \ (ww_sbHx :: GHC.Prim.Int#)
(ww1_sbHB :: GHC.Prim.Int#)
(ww2_sbHC :: GHC.Prim.Int#)
(ww3_sbHD :: GHC.Prim.Int#)
(w_sbHu :: String) ->
let {
p_sail [Dmd=<L,1*C1(U)>] :: ShowS
[LclId, Arity=1, Str=<L,U>, Unf=OtherCon []]
p_sail
= \ (x_X808 [OS=OneShot] :: String) ->
GHC.CString.unpackAppendCString#
Main.$fShowPoint6
(GHC.CString.unpackAppendCString#
Main.$fShowPoint5
(case GHC.Show.$wshowSignedInt
0#
ww1_sbHB
(++
@ Char
GHC.Show.showCommaSpace1
(GHC.CString.unpackAppendCString#
Main.$fShowPoint4
(case GHC.Show.$wshowSignedInt
0#
ww2_sbHC
(++
@ Char
GHC.Show.showCommaSpace1
(GHC.CString.unpackAppendCString#
Main.$fShowPoint3
(case GHC.Show.$wshowSignedInt
0#
ww3_sbHD
(GHC.CString.unpackAppendCString#
Main.$fShowPoint2 x_X808)
of
{ (# ww5_a8fM, ww6_a8fN #) ->
GHC.Types.: @ Char ww5_a8fM ww6_a8fN
})))
of
{ (# ww5_a8fM, ww6_a8fN #) ->
GHC.Types.: @ Char ww5_a8fM ww6_a8fN
})))
of
{ (# ww5_a8fM, ww6_a8fN #) ->
GHC.Types.: @ Char ww5_a8fM ww6_a8fN
})) } in
case GHC.Prim.>=# ww_sbHx 11# of {
__DEFAULT -> p_sail w_sbHu;
1# ->
GHC.Types.:
@ Char
GHC.Show.$fShow(,)4
(p_sail (GHC.Types.: @ Char GHC.Show.$fShow(,)2 w_sbHu))
}
-- RHS size: {terms: 15, types: 9, coercions: 0, joins: 0/0}
Main.$fShowPoint_$cshowsPrec [InlPrag=NOUSERINLINE[0]]
:: Int -> Point -> ShowS
[GblId,
Arity=3,
Str=<S(S),1*U(U)><S(SSS),1*U(U,U,U)><L,U>,
Unf=Unf{Src=InlineStable, TopLvl=True, Value=True, ConLike=True,
WorkFree=True, Expandable=True,
Guidance=ALWAYS_IF(arity=3,unsat_ok=True,boring_ok=False)
Tmpl= \ (w_sbHs [Occ=Once!] :: Int)
(w1_sbHt [Occ=Once!] :: Point)
(w2_sbHu [Occ=Once] :: String) ->
case w_sbHs of { GHC.Types.I# ww1_sbHx [Occ=Once] ->
case w1_sbHt of
{ Point ww3_sbHB [Occ=Once] ww4_sbHC [Occ=Once]
ww5_sbHD [Occ=Once] ->
Main.$w$cshowsPrec ww1_sbHx ww3_sbHB ww4_sbHC ww5_sbHD w2_sbHu
}
}}]
Main.$fShowPoint_$cshowsPrec
= \ (w_sbHs :: Int) (w1_sbHt :: Point) (w2_sbHu :: String) ->
case w_sbHs of { GHC.Types.I# ww1_sbHx ->
case w1_sbHt of { Point ww3_sbHB ww4_sbHC ww5_sbHD ->
Main.$w$cshowsPrec ww1_sbHx ww3_sbHB ww4_sbHC ww5_sbHD w2_sbHu
}
}
-- RHS size: {terms: 10, types: 6, coercions: 0, joins: 0/0}
Main.$fShowPoint_$cshow :: Point -> String
[GblId,
Arity=1,
Str=<S(SSS),1*U(U,U,U)>,
Unf=Unf{Src=InlineStable, TopLvl=True, Value=True, ConLike=True,
WorkFree=True, Expandable=True,
Guidance=ALWAYS_IF(arity=1,unsat_ok=True,boring_ok=False)
Tmpl= \ (x_a7Zd [Occ=Once] :: Point) ->
Main.$fShowPoint_$cshowsPrec
Main.$fShowPoint7 x_a7Zd (GHC.Types.[] @ Char)}]
Main.$fShowPoint_$cshow
= \ (x_a7Zd :: Point) ->
case x_a7Zd of { Point ww1_sbHB ww2_sbHC ww3_sbHD ->
Main.$w$cshowsPrec
0# ww1_sbHB ww2_sbHC ww3_sbHD (GHC.Types.[] @ Char)
}
-- RHS size: {terms: 11, types: 6, coercions: 0, joins: 0/0}
Main.$fShowPoint1 :: Point -> ShowS
[GblId,
Arity=2,
Str=<S(SSS),1*U(U,U,U)><L,U>,
Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
WorkFree=True, Expandable=True, Guidance=IF_ARGS [20 0] 70 0}]
Main.$fShowPoint1
= \ (w_sbHt :: Point) (w1_sbHu :: String) ->
case w_sbHt of { Point ww1_sbHB ww2_sbHC ww3_sbHD ->
Main.$w$cshowsPrec 0# ww1_sbHB ww2_sbHC ww3_sbHD w1_sbHu
}
-- RHS size: {terms: 6, types: 4, coercions: 0, joins: 0/0}
Main.$fShowPoint_$cshowList :: [Point] -> ShowS
[GblId,
Arity=2,
Str=<S,1*U><L,U>,
Unf=Unf{Src=InlineStable, TopLvl=True, Value=True, ConLike=True,
WorkFree=True, Expandable=True,
Guidance=ALWAYS_IF(arity=2,unsat_ok=True,boring_ok=False)
Tmpl= \ (ls_a7Z7 [Occ=Once] :: [Point])
(s_a7Z8 [Occ=Once] :: String) ->
GHC.Show.showList__ @ Point Main.$fShowPoint1 ls_a7Z7 s_a7Z8}]
Main.$fShowPoint_$cshowList
= \ (ls_a7Z7 :: [Point]) (s_a7Z8 :: String) ->
GHC.Show.showList__ @ Point Main.$fShowPoint1 ls_a7Z7 s_a7Z8
-- RHS size: {terms: 4, types: 1, coercions: 0, joins: 0/0}
Main.$fShowPoint [InlPrag=NOUSERINLINE CONLIKE] :: Show Point
[GblId[DFunId],
Str=m,
Unf=DFun: \ ->
GHC.Show.C:Show TYPE: Point
Main.$fShowPoint_$cshowsPrec
Main.$fShowPoint_$cshow
Main.$fShowPoint_$cshowList]
Main.$fShowPoint
= GHC.Show.C:Show
@ Point
Main.$fShowPoint_$cshowsPrec
Main.$fShowPoint_$cshow
Main.$fShowPoint_$cshowList
-- RHS size: {terms: 1, types: 0, coercions: 0, joins: 0/0}
lvl2_rcBJ :: GHC.Prim.Addr#
[GblId, Caf=NoCafRefs]
lvl2_rcBJ = "byteString = "#
-- RHS size: {terms: 1, types: 0, coercions: 0, joins: 0/0}
lvl3_rcBK :: GHC.Prim.Addr#
[GblId, Caf=NoCafRefs]
lvl3_rcBK = "start = "#
-- RHS size: {terms: 1, types: 0, coercions: 0, joins: 0/0}
lvl4_rcBL :: GHC.Prim.Addr#
[GblId, Caf=NoCafRefs]
lvl4_rcBL = "end = "#
-- RHS size: {terms: 89, types: 33, coercions: 0, joins: 0/1}
Main.$fShowToken_$cshowsPrec :: Int -> Token -> ShowS
[GblId, Arity=2, Str=<S(S),1*U(U)><S,1*U(U,U,U,U,U,U,U,U,U,U)>]
Main.$fShowToken_$cshowsPrec
= \ (a_a6TD :: Int) (ds_d7QM :: Token) ->
case ds_d7QM of
{ Token dt_d7Wp dt1_d7Wq dt2_d7Wr dt3_d7Ws dt4_d7Wt dt5_d7Wu
dt6_d7Wv dt7_d7Ww dt8_d7Wx dt9_d7Wy ->
case a_a6TD of { GHC.Types.I# x_i8b5 ->
let {
lvl12_sanx :: [Char]
[LclId]
lvl12_sanx
= Data.ByteString.Internal.$wunpackAppendCharsLazy
dt_d7Wp dt1_d7Wq dt2_d7Wr dt3_d7Ws (GHC.Types.[] @ Char) } in
case GHC.Prim.>=# x_i8b5 11# of {
__DEFAULT ->
\ (x1_X80j :: String) ->
++
@ Char
f1_rcBI
(GHC.CString.unpackAppendCString#
lvl2_rcBJ
(GHC.Types.:
@ Char
GHC.Show.$fShow(,)3
(GHC.Show.showLitString
lvl12_sanx
(GHC.Types.:
@ Char
GHC.Show.$fShow(,)3
(++
@ Char
GHC.Show.showCommaSpace1
(GHC.CString.unpackAppendCString#
lvl3_rcBK
(Main.$w$cshowsPrec
0#
dt4_d7Wt
dt5_d7Wu
dt6_d7Wv
(++
@ Char
GHC.Show.showCommaSpace1
(GHC.CString.unpackAppendCString#
lvl4_rcBL
(Main.$w$cshowsPrec
0#
dt7_d7Ww
dt8_d7Wx
dt9_d7Wy
(GHC.CString.unpackAppendCString#
Main.$fShowPoint2 x1_X80j)))))))))));
1# ->
\ (x1_a7Z0 :: String) ->
GHC.Types.:
@ Char
GHC.Show.$fShow(,)4
(++
@ Char
f1_rcBI
(GHC.CString.unpackAppendCString#
lvl2_rcBJ
(GHC.Types.:
@ Char
GHC.Show.$fShow(,)3
(GHC.Show.showLitString
lvl12_sanx
(GHC.Types.:
@ Char
GHC.Show.$fShow(,)3
(++
@ Char
GHC.Show.showCommaSpace1
(GHC.CString.unpackAppendCString#
lvl3_rcBK
(Main.$w$cshowsPrec
0#
dt4_d7Wt
dt5_d7Wu
dt6_d7Wv
(++
@ Char
GHC.Show.showCommaSpace1
(GHC.CString.unpackAppendCString#
lvl4_rcBL
(Main.$w$cshowsPrec
0#
dt7_d7Ww
dt8_d7Wx
dt9_d7Wy
(GHC.CString.unpackAppendCString#
Main.$fShowPoint2
(GHC.Types.:
@ Char GHC.Show.$fShow(,)2 x1_a7Z0)))))))))))))
}
}
}
-- RHS size: {terms: 5, types: 2, coercions: 0, joins: 0/0}
Main.$fShowToken_$cshow :: Token -> String
[GblId,
Arity=1,
Str=<S,1*U(U,U,U,U,U,U,U,U,U,U)>,
Unf=Unf{Src=InlineStable, TopLvl=True, Value=True, ConLike=True,
WorkFree=True, Expandable=True,
Guidance=ALWAYS_IF(arity=1,unsat_ok=True,boring_ok=False)
Tmpl= \ (x_a7Zd [Occ=Once] :: Token) ->
Main.$fShowToken_$cshowsPrec
Main.$fShowPoint7 x_a7Zd (GHC.Types.[] @ Char)}]
Main.$fShowToken_$cshow
= \ (x_a7Zd :: Token) ->
Main.$fShowToken_$cshowsPrec
Main.$fShowPoint7 x_a7Zd (GHC.Types.[] @ Char)
-- RHS size: {terms: 2, types: 0, coercions: 0, joins: 0/0}
Main.$fShowToken1 :: Token -> ShowS
[GblId,
Arity=1,
Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
WorkFree=True, Expandable=True, Guidance=IF_ARGS [] 20 60}]
Main.$fShowToken1 = Main.$fShowToken_$cshowsPrec Main.$fShowPoint7
-- RHS size: {terms: 6, types: 4, coercions: 0, joins: 0/0}
Main.$fShowToken_$cshowList :: [Token] -> ShowS
[GblId,
Arity=2,
Str=<S,1*U><L,U>,
Unf=Unf{Src=InlineStable, TopLvl=True, Value=True, ConLike=True,
WorkFree=True, Expandable=True,
Guidance=ALWAYS_IF(arity=2,unsat_ok=True,boring_ok=False)
Tmpl= \ (ls_a7Z7 [Occ=Once] :: [Token])
(s_a7Z8 [Occ=Once] :: String) ->
GHC.Show.showList__ @ Token Main.$fShowToken1 ls_a7Z7 s_a7Z8}]
Main.$fShowToken_$cshowList
= \ (ls_a7Z7 :: [Token]) (s_a7Z8 :: String) ->
GHC.Show.showList__ @ Token Main.$fShowToken1 ls_a7Z7 s_a7Z8
-- RHS size: {terms: 4, types: 1, coercions: 0, joins: 0/0}
Main.$fShowToken [InlPrag=NOUSERINLINE CONLIKE] :: Show Token
[GblId[DFunId],
Str=m,
Unf=DFun: \ ->
GHC.Show.C:Show TYPE: Token
Main.$fShowToken_$cshowsPrec
Main.$fShowToken_$cshow
Main.$fShowToken_$cshowList]
Main.$fShowToken
= GHC.Show.C:Show
@ Token
Main.$fShowToken_$cshowsPrec
Main.$fShowToken_$cshow
Main.$fShowToken_$cshowList
Rec {
-- RHS size: {terms: 356, types: 312, coercions: 2, joins: 10/16}
$wsimple_rcBM
:: GHC.Prim.Addr#
-> GHC.ForeignPtr.ForeignPtrContents
-> GHC.Prim.Int#
-> GHC.Prim.Int#
-> GHC.Prim.Int#
-> GHC.Prim.Int#
-> GHC.Prim.Int#
-> GHC.Prim.State# GHC.Prim.RealWorld
-> (# GHC.Prim.State# GHC.Prim.RealWorld,
(Zepto.Result (), Point) #)
[GblId, Arity=8, Str=<S,U><L,U><S,U><S,U><L,U><L,U><L,U><L,U>]
$wsimple_rcBM
= \ (ww_sbJ3 :: GHC.Prim.Addr#)
(ww1_sbJ4 :: GHC.ForeignPtr.ForeignPtrContents)
(ww2_sbJ5 :: GHC.Prim.Int#)
(ww3_sbJ6 :: GHC.Prim.Int#)
(ww4_sbJa :: GHC.Prim.Int#)
(ww5_sbJb :: GHC.Prim.Int#)
(ww6_sbJc :: GHC.Prim.Int#)
(w_sbJ0 :: GHC.Prim.State# GHC.Prim.RealWorld) ->
join {
$w$j1_sbIL [InlPrag=NOUSERINLINE[0], Dmd=<C(C(S)),C(C1(U(U,U)))>]
:: GHC.Prim.State# GHC.Prim.RealWorld
-> GHC.Prim.Int#
-> (# GHC.Prim.State# GHC.Prim.RealWorld,
(Zepto.Result (), Point) #)
[LclId[JoinId(2)], Arity=2, Str=<S,U><S,U>, Unf=OtherCon []]
$w$j1_sbIL (w1_sbIF [OS=OneShot]
:: GHC.Prim.State# GHC.Prim.RealWorld)
(ww7_sbIJ [OS=OneShot] :: GHC.Prim.Int#)
= case GHC.Prim.touch#
@ 'GHC.Types.LiftedRep
@ GHC.ForeignPtr.ForeignPtrContents
ww1_sbJ4
w1_sbIF
of
{ __DEFAULT ->
case {__pkg_ccall bytestring-0.10.8.2 Addr#
-> Word#
-> Word#
-> State# RealWorld
-> (# State# RealWorld, Word# #)}_a7Ta
(GHC.Prim.plusAddr# ww_sbJ3 ww2_sbJ5)
(GHC.Prim.int2Word# ww7_sbIJ)
10##
GHC.Prim.realWorld#
of
{ (# ds10_a7Tf, ds11_a7Tg #) ->
case GHC.Prim.touch#
@ 'GHC.Types.LiftedRep
@ GHC.ForeignPtr.ForeignPtrContents
ww1_sbJ4
ds10_a7Tf
of
{ __DEFAULT ->
let {
ipv_s8dd [Dmd=<S,U>] :: GHC.Prim.Int#
[LclId]
ipv_s8dd = GHC.Prim.word2Int# ds11_a7Tg } in
join {
$j_saBE [Dmd=<L,1*C1(C1(C1(C1(U(U,U)))))>]
:: GHC.Prim.Addr#
-> GHC.ForeignPtr.ForeignPtrContents
-> GHC.Prim.Int#
-> GHC.Prim.Int#
-> (# GHC.Prim.State# GHC.Prim.RealWorld,
(Zepto.Result (), Point) #)
[LclId[JoinId(4)],
Arity=4,
Str=<S,U><L,U><S,U><S,U>,
Unf=OtherCon []]
$j_saBE (ipv1_s8dw [OS=OneShot] :: GHC.Prim.Addr#)
(ipv2_s8dx [OS=OneShot] :: GHC.ForeignPtr.ForeignPtrContents)
(ipv3_s8dy [OS=OneShot] :: GHC.Prim.Int#)
(ipv4_s8dz [OS=OneShot] :: GHC.Prim.Int#)
= join {
$w$j2_sbIo [InlPrag=NOUSERINLINE[0], Dmd=<C(C(S)),C(C1(U(U,U)))>]
:: GHC.Prim.State# GHC.Prim.RealWorld
-> GHC.Prim.Int#
-> (# GHC.Prim.State# GHC.Prim.RealWorld,
(Zepto.Result (), Point) #)
[LclId[JoinId(2)], Arity=2, Str=<S,U><L,U>, Unf=OtherCon []]
$w$j2_sbIo (w2_sbIi [OS=OneShot]
:: GHC.Prim.State# GHC.Prim.RealWorld)
(ww8_sbIm [OS=OneShot] :: GHC.Prim.Int#)
= case GHC.Prim.touch#
@ 'GHC.Types.LiftedRep
@ GHC.ForeignPtr.ForeignPtrContents
ipv2_s8dx
w2_sbIi
of
{ __DEFAULT ->
let {
ipv5_s8dN :: GHC.Prim.Int#
[LclId]
ipv5_s8dN = GHC.Prim.+# ww4_sbJa ipv_s8dd } in
case GHC.IO.Handle.Text.hPutStr2
GHC.IO.Handle.FD.stdout
(Main.$fShowToken_$cshowsPrec
Main.$fShowPoint7
(Main.Token
ww_sbJ3
ww1_sbJ4
ww2_sbJ5
ww7_sbIJ
ww4_sbJa
ww5_sbJb
ww6_sbJc
ipv5_s8dN
ipv4_s8dz
ww8_sbIm)
(GHC.Types.[] @ Char))
GHC.Types.True
w_sbJ0
of
{ (# ipv6_X8rK, ipv7_X8rM #) ->
case ipv7_X8rM of { () ->
let {
a1_sb1b [Dmd=<S,U>] :: GHC.Prim.Int#
[LclId]
a1_sb1b = GHC.Prim.+# ww2_sbJ5 ww7_sbIJ } in
let {
a2_sb1c [Dmd=<S,U>] :: GHC.Prim.Int#
[LclId]
a2_sb1c = GHC.Prim.-# ww3_sbJ6 ww7_sbIJ } in
join {
$w$j3_sbI5 [InlPrag=NOUSERINLINE[0], Dmd=<C(C(S)),C(C1(U(U,U)))>]
:: GHC.Prim.State# GHC.Prim.RealWorld
-> GHC.Prim.Int#
-> (# GHC.Prim.State# GHC.Prim.RealWorld,
(Zepto.Result (), Point) #)
[LclId[JoinId(2)], Arity=2, Str=<S,U><S,U>, Unf=OtherCon []]
$w$j3_sbI5 (w3_sbHZ [OS=OneShot]
:: GHC.Prim.State# GHC.Prim.RealWorld)
(ww9_sbI3 [OS=OneShot] :: GHC.Prim.Int#)
= case GHC.Prim.touch#
@ 'GHC.Types.LiftedRep
@ GHC.ForeignPtr.ForeignPtrContents
ww1_sbJ4
w3_sbHZ
of
{ __DEFAULT ->
let {
a3_sb6l [Dmd=<S,U>] :: GHC.Prim.Int#
[LclId]
a3_sb6l = GHC.Prim.-# a2_sb1c ww9_sbI3 } in
case GHC.Prim.<=# a3_sb6l 0# of {
__DEFAULT ->
$wsimple_rcBM
ww_sbJ3
ww1_sbJ4
(GHC.Prim.+# a1_sb1b ww9_sbI3)
a3_sb6l
ipv5_s8dN
ipv4_s8dz
ww8_sbIm
ipv6_X8rK;
1# ->
(# ipv6_X8rK,
(Zepto.OK
@ ()
GHC.Tuple.()
((Data.ByteString.Internal.PS
ww_sbJ3 ww1_sbJ4 (GHC.Prim.+# a1_sb1b ww9_sbI3) a3_sb6l)
`cast` (Sym (Zepto.N:S[0])
:: (ByteString :: *) ~R# (Zepto.S :: *))),
Main.Point ipv5_s8dN ipv4_s8dz ww8_sbIm) #)
}
} } in
join {
exit_X31 [Dmd=<L,C(U(U,U))>]
:: GHC.Prim.State# GHC.Prim.RealWorld
-> (# GHC.Prim.State# GHC.Prim.RealWorld,
(Zepto.Result (), Point) #)
[LclId[JoinId(1)], Arity=1, Str=<S,U>]
exit_X31 (w3_sbI8 [OS=OneShot]
:: GHC.Prim.State# GHC.Prim.RealWorld)
= jump $w$j3_sbI5 w3_sbI8 a2_sb1c } in
joinrec {
$wgo1_sbIh [InlPrag=NOUSERINLINE[0], Occ=LoopBreaker]
:: GHC.Prim.Addr#
-> GHC.Prim.Int#
-> GHC.Prim.State# GHC.Prim.RealWorld
-> (# GHC.Prim.State# GHC.Prim.RealWorld,
(Zepto.Result (), Point) #)
[LclId[JoinId(3)], Arity=3, Str=<L,U><S,U><S,U>, Unf=OtherCon []]
$wgo1_sbIh (ww9_sbIb :: GHC.Prim.Addr#)
(ww10_sbIf :: GHC.Prim.Int#)
(w3_sbI8 :: GHC.Prim.State# GHC.Prim.RealWorld)
= case GHC.Prim.>=# ww10_sbIf a2_sb1c of {
__DEFAULT ->
case GHC.Prim.readWord8OffAddr#
@ GHC.Prim.RealWorld ww9_sbIb 0# w3_sbI8
of
{ (# ipv8_i8co, ipv9_i8cp #) ->
case ipv9_i8cp of {
__DEFAULT -> jump $w$j3_sbI5 ipv8_i8co ww10_sbIf;
10## ->
jump $wgo1_sbIh
(GHC.Prim.plusAddr# ww9_sbIb 1#)
(GHC.Prim.+# ww10_sbIf 1#)
ipv8_i8co;
13## ->
jump $wgo1_sbIh
(GHC.Prim.plusAddr# ww9_sbIb 1#)
(GHC.Prim.+# ww10_sbIf 1#)
ipv8_i8co;
32## ->
jump $wgo1_sbIh
(GHC.Prim.plusAddr# ww9_sbIb 1#)
(GHC.Prim.+# ww10_sbIf 1#)
ipv8_i8co
}
};
1# -> jump exit_X31 w3_sbI8
}; } in
jump $wgo1_sbIh
(GHC.Prim.plusAddr# ww_sbJ3 a1_sb1b) 0# GHC.Prim.realWorld#
}
}
} } in
join {
exit_X2R [Dmd=<L,C(U(U,U))>]
:: GHC.Prim.State# GHC.Prim.RealWorld
-> (# GHC.Prim.State# GHC.Prim.RealWorld,
(Zepto.Result (), Point) #)
[LclId[JoinId(1)], Arity=1, Str=<S,U>]
exit_X2R (w2_sbIr [OS=OneShot]
:: GHC.Prim.State# GHC.Prim.RealWorld)
= jump $w$j2_sbIo w2_sbIr ipv4_s8dz } in
joinrec {
$wgo1_sbIA [InlPrag=NOUSERINLINE[0], Occ=LoopBreaker]
:: GHC.Prim.Addr#
-> GHC.Prim.Int#
-> GHC.Prim.State# GHC.Prim.RealWorld
-> (# GHC.Prim.State# GHC.Prim.RealWorld,
(Zepto.Result (), Point) #)
[LclId[JoinId(3)], Arity=3, Str=<L,U><S,U><S,U>, Unf=OtherCon []]
$wgo1_sbIA (ww8_sbIu :: GHC.Prim.Addr#)
(ww9_sbIy :: GHC.Prim.Int#)
(w2_sbIr :: GHC.Prim.State# GHC.Prim.RealWorld)
= case GHC.Prim.>=# ww9_sbIy ipv4_s8dz of {
__DEFAULT ->
case GHC.Prim.readWord8OffAddr#
@ GHC.Prim.RealWorld ww8_sbIu 0# w2_sbIr
of
{ (# ipv5_i7Ul, ipv6_i7Um #) ->
case ipv6_i7Um of {
__DEFAULT -> jump $w$j2_sbIo ipv5_i7Ul ww9_sbIy;
32## ->
jump $wgo1_sbIA
(GHC.Prim.plusAddr# ww8_sbIu 1#)
(GHC.Prim.+# ww9_sbIy 1#)
ipv5_i7Ul
}
};
1# -> jump exit_X2R w2_sbIr
}; } in
jump $wgo1_sbIA
(GHC.Prim.plusAddr# ipv1_s8dw ipv3_s8dy)
0#
GHC.Prim.realWorld# } in
case ipv_s8dd of {
__DEFAULT ->
case $wgo_rcBy
@ GHC.Types.Any
(GHC.Prim.plusAddr# ww_sbJ3 ww2_sbJ5)
(GHC.Prim.-# ww7_sbIJ 1#)
GHC.Prim.realWorld#
of
{ (# ipv1_i89C, ipv2_i89D #) ->
case GHC.Prim.touch#
@ 'GHC.Types.LiftedRep
@ GHC.ForeignPtr.ForeignPtrContents
ww1_sbJ4
ipv1_i89C
of
{ __DEFAULT ->
case ipv2_i89D of {
Nothing -> jump $j_saBE ww_sbJ3 ww1_sbJ4 ww2_sbJ5 ww7_sbIJ;
Just a1_i88S ->
case a1_i88S of { GHC.Types.I# x_a8aI ->
let {
x1_i8aU [Dmd=<S,U>] :: GHC.Prim.Int#
[LclId]
x1_i8aU = GHC.Prim.+# x_a8aI 1# } in
case GHC.Prim.<=# x1_i8aU 0# of {
__DEFAULT ->
case GHC.Prim.>=# x1_i8aU ww7_sbIJ of {
__DEFAULT ->
jump $j_saBE
ww_sbJ3
ww1_sbJ4
(GHC.Prim.+# ww2_sbJ5 x1_i8aU)
(GHC.Prim.-# ww7_sbIJ x1_i8aU);
1# ->
jump $j_saBE
__NULL Data.ByteString.Internal.$fMonoidByteString1 0# 0#
};
1# -> jump $j_saBE ww_sbJ3 ww1_sbJ4 ww2_sbJ5 ww7_sbIJ
}
}
}
}
};
0# -> jump $j_saBE ww_sbJ3 ww1_sbJ4 ww2_sbJ5 ww7_sbIJ
}
}
}
} } in
join {
exit_X2F [Dmd=<L,C(U(U,U))>]
:: GHC.Prim.State# GHC.Prim.RealWorld
-> (# GHC.Prim.State# GHC.Prim.RealWorld,
(Zepto.Result (), Point) #)
[LclId[JoinId(1)], Arity=1, Str=<S,U>]
exit_X2F (w1_sbIO [OS=OneShot]
:: GHC.Prim.State# GHC.Prim.RealWorld)
= jump $w$j1_sbIL w1_sbIO ww3_sbJ6 } in
joinrec {
$wgo1_sbIX [InlPrag=NOUSERINLINE[0], Occ=LoopBreaker]
:: GHC.Prim.Addr#
-> GHC.Prim.Int#
-> GHC.Prim.State# GHC.Prim.RealWorld
-> (# GHC.Prim.State# GHC.Prim.RealWorld,
(Zepto.Result (), Point) #)
[LclId[JoinId(3)], Arity=3, Str=<L,U><S,U><S,U>, Unf=OtherCon []]
$wgo1_sbIX (ww7_sbIR :: GHC.Prim.Addr#)
(ww8_sbIV :: GHC.Prim.Int#)
(w1_sbIO :: GHC.Prim.State# GHC.Prim.RealWorld)
= case GHC.Prim.>=# ww8_sbIV ww3_sbJ6 of {
__DEFAULT ->
case GHC.Prim.readWord8OffAddr#
@ GHC.Prim.RealWorld ww7_sbIR 0# w1_sbIO
of
{ (# ipv2_i8co, ipv3_i8cp #) ->
case ipv3_i8cp of {
__DEFAULT ->
jump $wgo1_sbIX
(GHC.Prim.plusAddr# ww7_sbIR 1#)
(GHC.Prim.+# ww8_sbIV 1#)
ipv2_i8co;
10## -> jump $w$j1_sbIL ipv2_i8co ww8_sbIV;
13## -> jump $w$j1_sbIL ipv2_i8co ww8_sbIV;
32## -> jump $w$j1_sbIL ipv2_i8co ww8_sbIV
}
};
1# -> jump exit_X2F w1_sbIO
}; } in
jump $wgo1_sbIX
(GHC.Prim.plusAddr# ww_sbJ3 ww2_sbJ5) 0# GHC.Prim.realWorld#
end Rec }
-- RHS size: {terms: 1, types: 0, coercions: 0, joins: 0/0}
lvl5_rcBN :: GHC.Prim.Addr#
[GblId, Caf=NoCafRefs]
lvl5_rcBN = "silent"#
-- RHS size: {terms: 1, types: 0, coercions: 0, joins: 0/0}
lvl6_rcBO :: GHC.Prim.Addr#
[GblId, Caf=NoCafRefs]
lvl6_rcBO = "print"#
-- RHS size: {terms: 1, types: 0, coercions: 0, joins: 0/0}
lvl7_rcBP :: GHC.Prim.Addr#
[GblId, Caf=NoCafRefs]
lvl7_rcBP = "count"#
-- RHS size: {terms: 155, types: 219, coercions: 25, joins: 0/0}
Main.main1
:: GHC.Prim.State# GHC.Prim.RealWorld
-> (# GHC.Prim.State# GHC.Prim.RealWorld, () #)
[GblId, Arity=1, Str=<S,U>]
Main.main1
= \ (s_i8ng :: GHC.Prim.State# GHC.Prim.RealWorld) ->
case ((Foreign.Marshal.Alloc.allocaBytesAligned
@ Foreign.C.Types.CInt
@ [String]
Foreign.Storable.$fStorableBool7
Foreign.Storable.$fStorableBool7
(System.Environment.getArgs1
`cast` (<GHC.Ptr.Ptr Foreign.C.Types.CInt>_R
->_R Sym (GHC.Types.N:IO[0] <[String]>_R)
:: (GHC.Ptr.Ptr Foreign.C.Types.CInt
-> GHC.Prim.State# GHC.Prim.RealWorld
-> (# GHC.Prim.State# GHC.Prim.RealWorld, [String] #) :: *)
~R# (GHC.Ptr.Ptr Foreign.C.Types.CInt -> IO [String] :: *))))
`cast` (GHC.Types.N:IO[0] <[String]>_R
:: (IO [String] :: *)
~R# (GHC.Prim.State# GHC.Prim.RealWorld
-> (# GHC.Prim.State# GHC.Prim.RealWorld, [String] #) :: *)))
s_i8ng
of
{ (# ipv_i8nj, ipv1_i8nk #) ->
case ipv1_i8nk of {
[] -> $wfail_rcBx ipv_i8nj;
: fp_a50t ds_d7PU ->
case ds_d7PU of {
[] -> $wfail_rcBx ipv_i8nj;
: mode_a50u ds2_d7PV ->
case GHC.Base.eqString
mode_a50u (GHC.CString.unpackCString# lvl7_rcBP)
of {
False ->
case GHC.Base.eqString
mode_a50u (GHC.CString.unpackCString# lvl6_rcBO)
of {
False ->
case GHC.Base.eqString
mode_a50u (GHC.CString.unpackCString# lvl5_rcBN)
of {
False -> (# ipv_i8nj, GHC.Tuple.() #);
True ->
case System.IO.withBinaryFile1
@ ByteString
fp_a50t
GHC.IO.IOMode.ReadMode
(Data.ByteString.readFile2
`cast` (<GHC.IO.Handle.Types.Handle>_R
->_R Sym (GHC.Types.N:IO[0] <ByteString>_R)
:: (GHC.IO.Handle.Types.Handle
-> GHC.Prim.State# GHC.Prim.RealWorld
-> (# GHC.Prim.State# GHC.Prim.RealWorld,
ByteString #) :: *)
~R# (GHC.IO.Handle.Types.Handle
-> IO ByteString :: *)))
ipv_i8nj
of
{ (# ipv2_X8uc, ipv3_X8ue #) ->
case GHC.Prim.seq#
@ (Either String ())
@ GHC.Prim.RealWorld
(case ipv3_X8ue of
{ Data.ByteString.Internal.PS ww1_sbHc ww2_sbHd ww3_sbHe
ww4_sbHf ->
case $w$ssimple__rcBG ww1_sbHc ww2_sbHd ww3_sbHe ww4_sbHf 1# of
{ (# ww6_sbKH, ww7_sbKI #) ->
case ww6_sbKH of {
Zepto.Fail err_i7RT -> Data.Either.Left @ String @ () err_i7RT;
Zepto.OK a1_i7RY ds4_i7RZ ->
Data.Either.Right @ String @ () a1_i7RY
}
}
})
ipv2_X8uc
of
{ (# ipv4_i9mX, ipv5_i9mY #) ->
(# ipv4_i9mX, GHC.Tuple.() #)
}
}
};
True ->
case System.IO.withBinaryFile1
@ ByteString
fp_a50t
GHC.IO.IOMode.ReadMode
(Data.ByteString.readFile2
`cast` (<GHC.IO.Handle.Types.Handle>_R
->_R Sym (GHC.Types.N:IO[0] <ByteString>_R)
:: (GHC.IO.Handle.Types.Handle
-> GHC.Prim.State# GHC.Prim.RealWorld
-> (# GHC.Prim.State# GHC.Prim.RealWorld,
ByteString #) :: *)
~R# (GHC.IO.Handle.Types.Handle -> IO ByteString :: *)))
ipv_i8nj
of
{ (# ipv2_X8u9, ipv3_X8ub #) ->
case ipv3_X8ub of
{ Data.ByteString.Internal.PS ww1_sbJ3 ww2_sbJ4 ww3_sbJ5
ww4_sbJ6 ->
case $wsimple_rcBM
ww1_sbJ3 ww2_sbJ4 ww3_sbJ5 ww4_sbJ6 1# 1# 0# ipv2_X8u9
of
{ (# ipv4_X8uf, ipv5_X8uh #) ->
case ipv5_X8uh of { (a1_a84n, s'_a84o) ->
case a1_a84n of { __DEFAULT -> (# ipv4_X8uf, GHC.Tuple.() #) }
}
}
}
}
};
True ->
case System.IO.withBinaryFile1
@ ByteString
fp_a50t
GHC.IO.IOMode.ReadMode
(Data.ByteString.readFile2
`cast` (<GHC.IO.Handle.Types.Handle>_R
->_R Sym (GHC.Types.N:IO[0] <ByteString>_R)
:: (GHC.IO.Handle.Types.Handle
-> GHC.Prim.State# GHC.Prim.RealWorld
-> (# GHC.Prim.State# GHC.Prim.RealWorld, ByteString #) :: *)
~R# (GHC.IO.Handle.Types.Handle -> IO ByteString :: *)))
ipv_i8nj
of
{ (# ipv2_X8u6, ipv3_X8u8 #) ->
case GHC.IO.Handle.Text.hPutStr2
GHC.IO.Handle.FD.stdout
(case ipv3_X8u8 of
{ Data.ByteString.Internal.PS ww1_sbEG ww2_sbEH ww3_sbEI
ww4_sbEJ ->
case $wsimple_count_rcBB
ww1_sbEG ww2_sbEH ww3_sbEI ww4_sbEJ 1# 1# 0# Main.$fShowPoint7
of
{ (# ww6_sbKB, ww7_sbKC #) ->
case ww6_sbKB of { (a1_X8bl, s'_X8bn) ->
case a1_X8bl of { __DEFAULT ->
case ww7_sbKC of { GHC.Types.I# ww9_a8fI ->
case GHC.Show.$wshowSignedInt 0# ww9_a8fI (GHC.Types.[] @ Char) of
{ (# ww11_a8fM, ww12_a8fN #) ->
GHC.Types.: @ Char ww11_a8fM ww12_a8fN
}
}
}
}
}
})
GHC.Types.True
ipv2_X8u6
of
{ (# ipv4_i9mX, ipv5_i9mY #) ->
(# ipv4_i9mX, GHC.Tuple.() #)
}
}
}
}
}
}
-- 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 () :: *))
-- RHS size: {terms: 1, types: 0, coercions: 0, joins: 0/0}
Main.$tc'Token3 :: GHC.Prim.Addr#
[GblId,
Caf=NoCafRefs,
Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
WorkFree=True, Expandable=True, Guidance=IF_ARGS [] 30 0}]
Main.$tc'Token3 = "'Token"#
-- RHS size: {terms: 2, types: 0, coercions: 0, joins: 0/0}
Main.$tc'Token2 :: 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.$tc'Token2 = GHC.Types.TrNameS Main.$tc'Token3
-- RHS size: {terms: 1, types: 0, coercions: 0, joins: 0/0}
Main.$tcToken2 :: GHC.Prim.Addr#
[GblId,
Caf=NoCafRefs,
Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
WorkFree=True, Expandable=True, Guidance=IF_ARGS [] 30 0}]
Main.$tcToken2 = "Token"#
-- RHS size: {terms: 2, types: 0, coercions: 0, joins: 0/0}
Main.$tcToken1 :: 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.$tcToken1 = GHC.Types.TrNameS Main.$tcToken2
-- RHS size: {terms: 1, types: 0, coercions: 0, joins: 0/0}
Main.$tc'P3 :: 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.$tc'P3 = "'P"#
-- RHS size: {terms: 2, types: 0, coercions: 0, joins: 0/0}
Main.$tc'P2 :: 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.$tc'P2 = GHC.Types.TrNameS Main.$tc'P3
-- RHS size: {terms: 1, types: 0, coercions: 0, joins: 0/0}
Main.$tcP3 :: 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.$tcP3 = "P"#
-- RHS size: {terms: 2, types: 0, coercions: 0, joins: 0/0}
Main.$tcP2 :: 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.$tcP2 = GHC.Types.TrNameS Main.$tcP3
-- RHS size: {terms: 1, types: 0, coercions: 0, joins: 0/0}
Main.$tc'Point3 :: GHC.Prim.Addr#
[GblId,
Caf=NoCafRefs,
Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
WorkFree=True, Expandable=True, Guidance=IF_ARGS [] 30 0}]
Main.$tc'Point3 = "'Point"#
-- RHS size: {terms: 2, types: 0, coercions: 0, joins: 0/0}
Main.$tc'Point2 :: 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.$tc'Point2 = GHC.Types.TrNameS Main.$tc'Point3
-- RHS size: {terms: 1, types: 0, coercions: 0, joins: 0/0}
Main.$tcPoint2 :: GHC.Prim.Addr#
[GblId,
Caf=NoCafRefs,
Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
WorkFree=True, Expandable=True, Guidance=IF_ARGS [] 30 0}]
Main.$tcPoint2 = "Point"#
-- RHS size: {terms: 2, types: 0, coercions: 0, joins: 0/0}
Main.$tcPoint1 :: 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.$tcPoint1 = GHC.Types.TrNameS Main.$tcPoint2
-- RHS size: {terms: 2, types: 0, coercions: 0, joins: 0/0}
$krep_rcBQ :: GHC.Types.KindRep
[GblId, Caf=NoCafRefs, Str=m2]
$krep_rcBQ = GHC.Types.KindRepVar 0#
-- RHS size: {terms: 3, types: 2, coercions: 0, joins: 0/0}
$krep1_rcBR :: [GHC.Types.KindRep]
[GblId, Caf=NoCafRefs, Str=m2]
$krep1_rcBR
= GHC.Types.:
@ GHC.Types.KindRep $krep_rcBQ (GHC.Types.[] @ GHC.Types.KindRep)
-- RHS size: {terms: 2, types: 0, coercions: 0, joins: 0/0}
$krep2_rcBS :: GHC.Types.KindRep
[GblId, Caf=NoCafRefs, Str=m2]
$krep2_rcBS = GHC.Types.KindRepVar 1#
-- RHS size: {terms: 3, types: 2, coercions: 0, joins: 0/0}
$krep3_rcBT :: [GHC.Types.KindRep]
[GblId, Caf=NoCafRefs, Str=m2]
$krep3_rcBT
= GHC.Types.:
@ GHC.Types.KindRep $krep2_rcBS (GHC.Types.[] @ GHC.Types.KindRep)
-- RHS size: {terms: 3, types: 1, coercions: 0, joins: 0/0}
$krep4_rcBU :: [GHC.Types.KindRep]
[GblId, Caf=NoCafRefs, Str=m2]
$krep4_rcBU
= GHC.Types.: @ GHC.Types.KindRep $krep_rcBQ $krep3_rcBT
-- RHS size: {terms: 3, types: 0, coercions: 0, joins: 0/0}
Main.$tcP1 [InlPrag=NOUSERINLINE[~]] :: GHC.Types.KindRep
[GblId, Caf=NoCafRefs, Str=m4]
Main.$tcP1
= GHC.Types.KindRepFun GHC.Types.krep$*Arr* GHC.Types.krep$*Arr*
-- RHS size: {terms: 3, types: 1, coercions: 0, joins: 0/0}
$krep5_rcBV :: GHC.Types.KindRep
[GblId, Caf=NoCafRefs, Str=m1]
$krep5_rcBV
= GHC.Types.KindRepTyConApp
Data.ByteString.Internal.$tcByteString
(GHC.Types.[] @ GHC.Types.KindRep)
-- RHS size: {terms: 3, types: 1, coercions: 0, joins: 0/0}
$krep6_rcBW :: GHC.Types.KindRep
[GblId, Caf=NoCafRefs, Str=m1]
$krep6_rcBW
= GHC.Types.KindRepTyConApp
GHC.Types.$tcInt (GHC.Types.[] @ GHC.Types.KindRep)
-- 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: 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: 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
-- RHS size: {terms: 7, types: 0, coercions: 0, joins: 0/0}
Main.$tcPoint :: GHC.Types.TyCon
[GblId,
Caf=NoCafRefs,
Str=m,
Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
WorkFree=True, Expandable=True, Guidance=IF_ARGS [] 10 70}]
Main.$tcPoint
= GHC.Types.TyCon
18129445357045554353##
11497670497407357583##
Main.$trModule
Main.$tcPoint1
0#
GHC.Types.krep$*
-- RHS size: {terms: 3, types: 1, coercions: 0, joins: 0/0}
$krep7_rcBX :: GHC.Types.KindRep
[GblId, Caf=NoCafRefs, Str=m1]
$krep7_rcBX
= GHC.Types.KindRepTyConApp
Main.$tcPoint (GHC.Types.[] @ GHC.Types.KindRep)
-- RHS size: {terms: 3, types: 1, coercions: 0, joins: 0/0}
$krep8_rcBY :: [GHC.Types.KindRep]
[GblId, Caf=NoCafRefs, Str=m2]
$krep8_rcBY
= GHC.Types.: @ GHC.Types.KindRep $krep7_rcBX $krep1_rcBR
-- RHS size: {terms: 3, types: 0, coercions: 0, joins: 0/0}
$krep9_rcBZ :: GHC.Types.KindRep
[GblId, Caf=NoCafRefs, Str=m1]
$krep9_rcBZ
= GHC.Types.KindRepTyConApp
Control.Monad.Trans.State.Strict.$tcStateT $krep8_rcBY
-- RHS size: {terms: 3, types: 1, coercions: 0, joins: 0/0}
$krep10_rcC0 :: [GHC.Types.KindRep]
[GblId, Caf=NoCafRefs, Str=m2]
$krep10_rcC0
= GHC.Types.: @ GHC.Types.KindRep $krep9_rcBZ $krep3_rcBT
-- RHS size: {terms: 3, types: 0, coercions: 0, joins: 0/0}
$krep11_rcC1 :: GHC.Types.KindRep
[GblId, Caf=NoCafRefs, Str=m1]
$krep11_rcC1
= GHC.Types.KindRepTyConApp Zepto.$tcZeptoT $krep10_rcC0
-- RHS size: {terms: 3, types: 0, coercions: 0, joins: 0/0}
$krep12_rcC2 :: GHC.Types.KindRep
[GblId, Caf=NoCafRefs, Str=m4]
$krep12_rcC2 = GHC.Types.KindRepFun $krep6_rcBW $krep7_rcBX
-- RHS size: {terms: 3, types: 0, coercions: 0, joins: 0/0}
$krep13_rcC3 :: GHC.Types.KindRep
[GblId, Caf=NoCafRefs, Str=m4]
$krep13_rcC3 = GHC.Types.KindRepFun $krep6_rcBW $krep12_rcC2
-- RHS size: {terms: 3, types: 0, coercions: 0, joins: 0/0}
Main.$tc'Point1 [InlPrag=NOUSERINLINE[~]] :: GHC.Types.KindRep
[GblId, Caf=NoCafRefs, Str=m4]
Main.$tc'Point1 = GHC.Types.KindRepFun $krep6_rcBW $krep13_rcC3
-- RHS size: {terms: 7, types: 0, coercions: 0, joins: 0/0}
Main.$tc'Point :: GHC.Types.TyCon
[GblId,
Caf=NoCafRefs,
Str=m,
Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
WorkFree=True, Expandable=True, Guidance=IF_ARGS [] 10 70}]
Main.$tc'Point
= GHC.Types.TyCon
16279505152029073500##
7140802812436523503##
Main.$trModule
Main.$tc'Point2
0#
Main.$tc'Point1
-- RHS size: {terms: 7, types: 0, coercions: 0, joins: 0/0}
Main.$tcP :: GHC.Types.TyCon
[GblId,
Caf=NoCafRefs,
Str=m,
Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
WorkFree=True, Expandable=True, Guidance=IF_ARGS [] 10 70}]
Main.$tcP
= GHC.Types.TyCon
12216406424693395175##
17495999887541595119##
Main.$trModule
Main.$tcP2
0#
Main.$tcP1
-- RHS size: {terms: 3, types: 0, coercions: 0, joins: 0/0}
$krep14_rcC4 :: GHC.Types.KindRep
[GblId, Caf=NoCafRefs, Str=m1]
$krep14_rcC4 = GHC.Types.KindRepTyConApp Main.$tcP $krep4_rcBU
-- RHS size: {terms: 3, types: 0, coercions: 0, joins: 0/0}
Main.$tc'P1 [InlPrag=NOUSERINLINE[~]] :: GHC.Types.KindRep
[GblId, Caf=NoCafRefs, Str=m4]
Main.$tc'P1 = GHC.Types.KindRepFun $krep11_rcC1 $krep14_rcC4
-- RHS size: {terms: 7, types: 0, coercions: 0, joins: 0/0}
Main.$tc'P :: GHC.Types.TyCon
[GblId,
Caf=NoCafRefs,
Str=m,
Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
WorkFree=True, Expandable=True, Guidance=IF_ARGS [] 10 70}]
Main.$tc'P
= GHC.Types.TyCon
8113726271547808428##
14655129069243200274##
Main.$trModule
Main.$tc'P2
2#
Main.$tc'P1
-- RHS size: {terms: 7, types: 0, coercions: 0, joins: 0/0}
Main.$tcToken :: GHC.Types.TyCon
[GblId,
Caf=NoCafRefs,
Str=m,
Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
WorkFree=True, Expandable=True, Guidance=IF_ARGS [] 10 70}]
Main.$tcToken
= GHC.Types.TyCon
7314202970098702604##
11629948393857996392##
Main.$trModule
Main.$tcToken1
0#
GHC.Types.krep$*
-- RHS size: {terms: 3, types: 1, coercions: 0, joins: 0/0}
$krep15_rcC5 :: GHC.Types.KindRep
[GblId, Caf=NoCafRefs, Str=m1]
$krep15_rcC5
= GHC.Types.KindRepTyConApp
Main.$tcToken (GHC.Types.[] @ GHC.Types.KindRep)
-- RHS size: {terms: 3, types: 0, coercions: 0, joins: 0/0}
$krep16_rcC6 :: GHC.Types.KindRep
[GblId, Caf=NoCafRefs, Str=m4]
$krep16_rcC6 = GHC.Types.KindRepFun $krep7_rcBX $krep15_rcC5
-- RHS size: {terms: 3, types: 0, coercions: 0, joins: 0/0}
$krep17_rcC7 :: GHC.Types.KindRep
[GblId, Caf=NoCafRefs, Str=m4]
$krep17_rcC7 = GHC.Types.KindRepFun $krep7_rcBX $krep16_rcC6
-- RHS size: {terms: 3, types: 0, coercions: 0, joins: 0/0}
Main.$tc'Token1 [InlPrag=NOUSERINLINE[~]] :: GHC.Types.KindRep
[GblId, Caf=NoCafRefs, Str=m4]
Main.$tc'Token1 = GHC.Types.KindRepFun $krep5_rcBV $krep17_rcC7
-- RHS size: {terms: 7, types: 0, coercions: 0, joins: 0/0}
Main.$tc'Token :: GHC.Types.TyCon
[GblId,
Caf=NoCafRefs,
Str=m,
Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
WorkFree=True, Expandable=True, Guidance=IF_ARGS [] 10 70}]
Main.$tc'Token
= GHC.Types.TyCon
14643330222071437989##
15473412705053287808##
Main.$trModule
Main.$tc'Token2
0#
Main.$tc'Token1
-- RHS size: {terms: 9, types: 12, coercions: 0, joins: 0/0}
byteString :: Token -> ByteString
[GblId[[RecSel]],
Arity=1,
Caf=NoCafRefs,
Str=<S(SLSSLLLLLL),1*U(U,U,U,U,A,A,A,A,A,A)>m,
Unf=Unf{Src=InlineStable, TopLvl=True, Value=True, ConLike=True,
WorkFree=True, Expandable=True,
Guidance=ALWAYS_IF(arity=1,unsat_ok=True,boring_ok=False)
Tmpl= \ (ds_d7PZ [Occ=Once!] :: Token) ->
case ds_d7PZ of
{ Token dt_d7Vt [Occ=Once] dt1_d7Vu [Occ=Once] dt2_d7Vv [Occ=Once]
dt3_d7Vw [Occ=Once] _ [Occ=Dead] _ [Occ=Dead] _ [Occ=Dead]
_ [Occ=Dead] _ [Occ=Dead] _ [Occ=Dead] ->
Data.ByteString.Internal.PS dt_d7Vt dt1_d7Vu dt2_d7Vv dt3_d7Vw
}}]
byteString
= \ (ds_d7PZ :: Token) ->
case ds_d7PZ of
{ Token dt_d7Vt dt1_d7Vu dt2_d7Vv dt3_d7Vw dt4_d7Vx dt5_d7Vy
dt6_d7Vz dt7_d7VA dt8_d7VB dt9_d7VC ->
Data.ByteString.Internal.PS dt_d7Vt dt1_d7Vu dt2_d7Vv dt3_d7Vw
}
-- RHS size: {terms: 8, types: 12, coercions: 0, joins: 0/0}
start :: Token -> Point
[GblId[[RecSel]],
Arity=1,
Caf=NoCafRefs,
Str=<S(LLLLSSSLLL),1*U(A,A,A,A,U,U,U,A,A,A)>m,
Unf=Unf{Src=InlineStable, TopLvl=True, Value=True, ConLike=True,
WorkFree=True, Expandable=True,
Guidance=ALWAYS_IF(arity=1,unsat_ok=True,boring_ok=False)
Tmpl= \ (ds_d7Q4 [Occ=Once!] :: Token) ->
case ds_d7Q4 of
{ Token _ [Occ=Dead] _ [Occ=Dead] _ [Occ=Dead] _ [Occ=Dead]
dt4_d7VH [Occ=Once] dt5_d7VI [Occ=Once] dt6_d7VJ [Occ=Once]
_ [Occ=Dead] _ [Occ=Dead] _ [Occ=Dead] ->
Main.Point dt4_d7VH dt5_d7VI dt6_d7VJ
}}]
start
= \ (ds_d7Q4 :: Token) ->
case ds_d7Q4 of
{ Token dt_d7VD dt1_d7VE dt2_d7VF dt3_d7VG dt4_d7VH dt5_d7VI
dt6_d7VJ dt7_d7VK dt8_d7VL dt9_d7VM ->
Main.Point dt4_d7VH dt5_d7VI dt6_d7VJ
}
-- RHS size: {terms: 8, types: 12, coercions: 0, joins: 0/0}
end :: Token -> Point
[GblId[[RecSel]],
Arity=1,
Caf=NoCafRefs,
Str=<S(LLLLLLLSSS),1*U(A,A,A,A,A,A,A,U,U,U)>m,
Unf=Unf{Src=InlineStable, TopLvl=True, Value=True, ConLike=True,
WorkFree=True, Expandable=True,
Guidance=ALWAYS_IF(arity=1,unsat_ok=True,boring_ok=False)
Tmpl= \ (ds_d7Q9 [Occ=Once!] :: Token) ->
case ds_d7Q9 of
{ Token _ [Occ=Dead] _ [Occ=Dead] _ [Occ=Dead] _ [Occ=Dead]
_ [Occ=Dead] _ [Occ=Dead] _ [Occ=Dead] dt7_d7VU [Occ=Once]
dt8_d7VV [Occ=Once] dt9_d7VW [Occ=Once] ->
Main.Point dt7_d7VU dt8_d7VV dt9_d7VW
}}]
end
= \ (ds_d7Q9 :: Token) ->
case ds_d7Q9 of
{ Token dt_d7VN dt1_d7VO dt2_d7VP dt3_d7VQ dt4_d7VR dt5_d7VS
dt6_d7VT dt7_d7VU dt8_d7VV dt9_d7VW ->
Main.Point dt7_d7VU dt8_d7VV dt9_d7VW
}
-- RHS size: {terms: 6, types: 5, coercions: 0, joins: 0/0}
line :: Point -> Int
[GblId[[RecSel]],
Arity=1,
Caf=NoCafRefs,
Str=<S(SLL),1*U(U,A,A)>m,
Unf=Unf{Src=InlineStable, TopLvl=True, Value=True, ConLike=True,
WorkFree=True, Expandable=True,
Guidance=ALWAYS_IF(arity=1,unsat_ok=True,boring_ok=False)
Tmpl= \ (ds_d7Qe [Occ=Once!] :: Point) ->
case ds_d7Qe of
{ Point dt_d7VX [Occ=Once] _ [Occ=Dead] _ [Occ=Dead] ->
GHC.Types.I# dt_d7VX
}}]
line
= \ (ds_d7Qe :: Point) ->
case ds_d7Qe of { Point dt_d7VX dt1_d7VY dt2_d7VZ ->
GHC.Types.I# dt_d7VX
}
-- RHS size: {terms: 6, types: 5, coercions: 0, joins: 0/0}
column :: Point -> Int
[GblId[[RecSel]],
Arity=1,
Caf=NoCafRefs,
Str=<S(LSL),1*U(A,U,A)>m,
Unf=Unf{Src=InlineStable, TopLvl=True, Value=True, ConLike=True,
WorkFree=True, Expandable=True,
Guidance=ALWAYS_IF(arity=1,unsat_ok=True,boring_ok=False)
Tmpl= \ (ds_d7Qj [Occ=Once!] :: Point) ->
case ds_d7Qj of
{ Point _ [Occ=Dead] dt1_d7W1 [Occ=Once] _ [Occ=Dead] ->
GHC.Types.I# dt1_d7W1
}}]
column
= \ (ds_d7Qj :: Point) ->
case ds_d7Qj of { Point dt_d7W0 dt1_d7W1 dt2_d7W2 ->
GHC.Types.I# dt1_d7W1
}
-- RHS size: {terms: 6, types: 5, coercions: 0, joins: 0/0}
indentation :: Point -> Int
[GblId[[RecSel]],
Arity=1,
Caf=NoCafRefs,
Str=<S(LLS),1*U(A,A,U)>m,
Unf=Unf{Src=InlineStable, TopLvl=True, Value=True, ConLike=True,
WorkFree=True, Expandable=True,
Guidance=ALWAYS_IF(arity=1,unsat_ok=True,boring_ok=False)
Tmpl= \ (ds_d7Qo [Occ=Once!] :: Point) ->
case ds_d7Qo of
{ Point _ [Occ=Dead] _ [Occ=Dead] dt2_d7W5 [Occ=Once] ->
GHC.Types.I# dt2_d7W5
}}]
indentation
= \ (ds_d7Qo :: Point) ->
case ds_d7Qo of { Point dt_d7W3 dt1_d7W4 dt2_d7W5 ->
GHC.Types.I# dt2_d7W5
}
-- RHS size: {terms: 26, types: 13, coercions: 0, joins: 0/0}
Main.$fEqPoint_$c== :: Point -> Point -> Bool
[GblId,
Arity=2,
Caf=NoCafRefs,
Str=<S(SLL),1*U(U,U,U)><S(SLL),1*U(U,U,U)>,
Unf=Unf{Src=InlineStable, TopLvl=True, Value=True, ConLike=True,
WorkFree=True, Expandable=True,
Guidance=ALWAYS_IF(arity=2,unsat_ok=True,boring_ok=False)
Tmpl= \ (ds_d7Qv [Occ=Once!] :: Point)
(ds1_d7Qw [Occ=Once!] :: Point) ->
case ds_d7Qv of
{ Point dt_d7W9 [Occ=Once] dt1_d7Wa [Occ=Once]
dt2_d7Wb [Occ=Once] ->
case ds1_d7Qw of
{ Point dt3_d7Wc [Occ=Once] dt4_d7Wd [Occ=Once]
dt5_d7We [Occ=Once] ->
case GHC.Prim.==# dt_d7W9 dt3_d7Wc of {
__DEFAULT -> GHC.Types.False;
1# ->
case GHC.Prim.==# dt1_d7Wa dt4_d7Wd of {
__DEFAULT -> GHC.Types.False;
1# -> GHC.Prim.tagToEnum# @ Bool (GHC.Prim.==# dt2_d7Wb dt5_d7We)
}
}
}
}}]
Main.$fEqPoint_$c==
= \ (ds_d7Qv :: Point) (ds1_d7Qw :: Point) ->
case ds_d7Qv of { Point dt_d7W9 dt1_d7Wa dt2_d7Wb ->
case ds1_d7Qw of { Point dt3_d7Wc dt4_d7Wd dt5_d7We ->
case GHC.Prim.==# dt_d7W9 dt3_d7Wc of {
__DEFAULT -> GHC.Types.False;
1# ->
case GHC.Prim.==# dt1_d7Wa dt4_d7Wd of {
__DEFAULT -> GHC.Types.False;
1# -> GHC.Prim.tagToEnum# @ Bool (GHC.Prim.==# dt2_d7Wb dt5_d7We)
}
}
}
}
-- RHS size: {terms: 30, types: 13, coercions: 0, joins: 0/0}
Main.$fEqPoint_$c/= [InlPrag=INLINE (sat-args=2)]
:: Point -> Point -> Bool
[GblId,
Arity=2,
Caf=NoCafRefs,
Str=<S(SLL),1*U(U,U,U)><S(SLL),1*U(U,U,U)>,
Unf=Unf{Src=InlineStable, TopLvl=True, Value=True, ConLike=True,
WorkFree=True, Expandable=True,
Guidance=ALWAYS_IF(arity=2,unsat_ok=False,boring_ok=False)
Tmpl= \ (x_i7Wh [Occ=Once!] :: Point)
(y_i7Wi [Occ=Once!] :: Point) ->
case x_i7Wh of
{ Point dt_d7W9 [Occ=Once] dt1_d7Wa [Occ=Once]
dt2_d7Wb [Occ=Once] ->
case y_i7Wi of
{ Point dt3_d7Wc [Occ=Once] dt4_d7Wd [Occ=Once]
dt5_d7We [Occ=Once] ->
case GHC.Prim.==# dt_d7W9 dt3_d7Wc of {
__DEFAULT -> GHC.Types.True;
1# ->
case GHC.Prim.==# dt1_d7Wa dt4_d7Wd of {
__DEFAULT -> GHC.Types.True;
1# ->
case GHC.Prim.==# dt2_d7Wb dt5_d7We of {
__DEFAULT -> GHC.Types.True;
1# -> GHC.Types.False
}
}
}
}
}}]
Main.$fEqPoint_$c/=
= \ (eta_X5t :: Point) (eta1_X4Q :: Point) ->
case eta_X5t of { Point dt_d7W9 dt1_d7Wa dt2_d7Wb ->
case eta1_X4Q of { Point dt3_d7Wc dt4_d7Wd dt5_d7We ->
case GHC.Prim.==# dt_d7W9 dt3_d7Wc of {
__DEFAULT -> GHC.Types.True;
1# ->
case GHC.Prim.==# dt1_d7Wa dt4_d7Wd of {
__DEFAULT -> GHC.Types.True;
1# ->
case GHC.Prim.==# dt2_d7Wb dt5_d7We of {
__DEFAULT -> GHC.Types.True;
1# -> GHC.Types.False
}
}
}
}
}
-- RHS size: {terms: 3, types: 1, coercions: 0, joins: 0/0}
Main.$fEqPoint [InlPrag=NOUSERINLINE CONLIKE] :: Eq Point
[GblId[DFunId],
Caf=NoCafRefs,
Str=m,
Unf=DFun: \ ->
GHC.Classes.C:Eq TYPE: Point
Main.$fEqPoint_$c==
Main.$fEqPoint_$c/=]
Main.$fEqPoint
= GHC.Classes.C:Eq @ Point Main.$fEqPoint_$c== Main.$fEqPoint_$c/=
-- RHS size: {terms: 5, types: 12, coercions: 0, joins: 0/0}
Main.$fNFDataToken_$crnf :: Token -> ()
[GblId,
Arity=1,
Caf=NoCafRefs,
Str=<S,1*H>,
Unf=Unf{Src=InlineStable, TopLvl=True, Value=True, ConLike=True,
WorkFree=True, Expandable=True,
Guidance=ALWAYS_IF(arity=1,unsat_ok=True,boring_ok=False)
Tmpl= \ (x_X83x [Occ=Once!] :: Token) ->
case x_X83x of
{ Token _ [Occ=Dead] _ [Occ=Dead] _ [Occ=Dead] _ [Occ=Dead]
_ [Occ=Dead] _ [Occ=Dead] _ [Occ=Dead] _ [Occ=Dead] _ [Occ=Dead]
_ [Occ=Dead] ->
GHC.Tuple.()
}}]
Main.$fNFDataToken_$crnf
= \ (x_X83x :: Token) ->
case x_X83x of
{ Token dt_d7Wz dt1_d7WA dt2_d7WB dt3_d7WC dt4_d7WD dt5_d7WE
dt6_d7WF dt7_d7WG dt8_d7WH dt9_d7WI ->
GHC.Tuple.()
}
-- RHS size: {terms: 1, types: 0, coercions: 3, joins: 0/0}
Main.$fNFDataToken [InlPrag=INLINE (sat-args=0)] :: NFData Token
[GblId[DFunId(nt)],
Arity=1,
Caf=NoCafRefs,
Str=<S,1*H>,
Unf=Unf{Src=InlineStable, TopLvl=True, Value=True, ConLike=True,
WorkFree=True, Expandable=True,
Guidance=ALWAYS_IF(arity=0,unsat_ok=False,boring_ok=True)
Tmpl= Main.$fNFDataToken_$crnf
`cast` (Sym (Control.DeepSeq.N:NFData[0] <Token>_N)
:: (Token -> () :: *) ~R# (NFData Token :: Constraint))}]
Main.$fNFDataToken
= Main.$fNFDataToken_$crnf
`cast` (Sym (Control.DeepSeq.N:NFData[0] <Token>_N)
:: (Token -> () :: *) ~R# (NFData Token :: Constraint))
-- RHS size: {terms: 5, types: 5, coercions: 0, joins: 0/0}
Main.$fNFDataPoint_$crnf :: Point -> ()
[GblId,
Arity=1,
Caf=NoCafRefs,
Str=<S,1*H>,
Unf=Unf{Src=InlineStable, TopLvl=True, Value=True, ConLike=True,
WorkFree=True, Expandable=True,
Guidance=ALWAYS_IF(arity=1,unsat_ok=True,boring_ok=False)
Tmpl= \ (x_a7YN [Occ=Once!] :: Point) ->
case x_a7YN of { Point _ [Occ=Dead] _ [Occ=Dead] _ [Occ=Dead] ->
GHC.Tuple.()
}}]
Main.$fNFDataPoint_$crnf
= \ (x_a7YN :: Point) ->
case x_a7YN of { Point dt_d7Wm dt1_d7Wn dt2_d7Wo -> GHC.Tuple.() }
-- RHS size: {terms: 1, types: 0, coercions: 3, joins: 0/0}
Main.$fNFDataPoint [InlPrag=INLINE (sat-args=0)] :: NFData Point
[GblId[DFunId(nt)],
Arity=1,
Caf=NoCafRefs,
Str=<S,1*H>,
Unf=Unf{Src=InlineStable, TopLvl=True, Value=True, ConLike=True,
WorkFree=True, Expandable=True,
Guidance=ALWAYS_IF(arity=0,unsat_ok=False,boring_ok=True)
Tmpl= Main.$fNFDataPoint_$crnf
`cast` (Sym (Control.DeepSeq.N:NFData[0] <Point>_N)
:: (Point -> () :: *) ~R# (NFData Point :: Constraint))}]
Main.$fNFDataPoint
= Main.$fNFDataPoint_$crnf
`cast` (Sym (Control.DeepSeq.N:NFData[0] <Point>_N)
:: (Point -> () :: *) ~R# (NFData Point :: Constraint))
-- RHS size: {terms: 13, types: 95, coercions: 142, joins: 0/0}
Main.$fGenericPoint1
:: forall x.
Point
-> M1
C
('MetaCons "Point" 'PrefixI 'True)
(M1
S
('MetaSel
('Just "line") 'NoSourceUnpackedness 'SourceStrict 'DecidedUnpack)
(K1 R Int)
:*: (M1
S
('MetaSel
('Just "column")
'NoSourceUnpackedness
'SourceStrict
'DecidedUnpack)
(K1 R Int)
:*: M1
S
('MetaSel
('Just "indentation")
'NoSourceUnpackedness
'SourceStrict
'DecidedUnpack)
(K1 R Int)))
x
[GblId,
Arity=1,
Caf=NoCafRefs,
Str=<S,1*U(U,U,U)>m,
Unf=Unf{Src=InlineStable, TopLvl=True, Value=True, ConLike=True,
WorkFree=True, Expandable=True,
Guidance=ALWAYS_IF(arity=1,unsat_ok=True,boring_ok=False)
Tmpl= \ (@ x_a7sI) (x1_a6Tv [Occ=Once!] :: Point) ->
case x1_a6Tv of
{ Point dt_d7Wm [Occ=Once] dt1_d7Wn [Occ=Once]
dt2_d7Wo [Occ=Once] ->
(GHC.Generics.:*:
@ *
@ (M1
S
('MetaSel
('Just "line") 'NoSourceUnpackedness 'SourceStrict 'DecidedUnpack)
(K1 R Int))
@ (M1
S
('MetaSel
('Just "column")
'NoSourceUnpackedness
'SourceStrict
'DecidedUnpack)
(K1 R Int)
:*: M1
S
('MetaSel
('Just "indentation")
'NoSourceUnpackedness
'SourceStrict
'DecidedUnpack)
(K1 R Int))
@ x_a7sI
((GHC.Types.I# dt_d7Wm)
`cast` (Sym (GHC.Generics.N:K1[0]
<*>_N <R>_P <Int>_R <x_a7sI>_P) ; Sym (GHC.Generics.N:M1[0]
<*>_N
<S>_P
<'MetaSel
('Just "line")
'NoSourceUnpackedness
'SourceStrict
'DecidedUnpack>_P
<K1
R
Int>_R) <x_a7sI>_N
:: (Int :: *)
~R# (M1
S
('MetaSel
('Just "line")
'NoSourceUnpackedness
'SourceStrict
'DecidedUnpack)
(K1 R Int)
x_a7sI :: *)))
(GHC.Generics.:*:
@ *
@ (M1
S
('MetaSel
('Just "column")
'NoSourceUnpackedness
'SourceStrict
'DecidedUnpack)
(K1 R Int))
@ (M1
S
('MetaSel
('Just "indentation")
'NoSourceUnpackedness
'SourceStrict
'DecidedUnpack)
(K1 R Int))
@ x_a7sI
((GHC.Types.I# dt1_d7Wn)
`cast` (Sym (GHC.Generics.N:K1[0]
<*>_N <R>_P <Int>_R <x_a7sI>_P) ; Sym (GHC.Generics.N:M1[0]
<*>_N
<S>_P
<'MetaSel
('Just
"column")
'NoSourceUnpackedness
'SourceStrict
'DecidedUnpack>_P
<K1
R
Int>_R) <x_a7sI>_N
:: (Int :: *)
~R# (M1
S
('MetaSel
('Just "column")
'NoSourceUnpackedness
'SourceStrict
'DecidedUnpack)
(K1 R Int)
x_a7sI :: *)))
((GHC.Types.I# dt2_d7Wo)
`cast` (Sym (GHC.Generics.N:K1[0]
<*>_N <R>_P <Int>_R <x_a7sI>_P) ; Sym (GHC.Generics.N:M1[0]
<*>_N
<S>_P
<'MetaSel
('Just
"indentation")
'NoSourceUnpackedness
'SourceStrict
'DecidedUnpack>_P
<K1
R
Int>_R) <x_a7sI>_N
:: (Int :: *)
~R# (M1
S
('MetaSel
('Just "indentation")
'NoSourceUnpackedness
'SourceStrict
'DecidedUnpack)
(K1 R Int)
x_a7sI :: *)))))
`cast` (Sym (GHC.Generics.N:M1[0]
<*>_N
<C>_P
<'MetaCons "Point" 'PrefixI 'True>_P
<M1
S
('MetaSel
('Just "line")
'NoSourceUnpackedness
'SourceStrict
'DecidedUnpack)
(K1 R Int)
:*: (M1
S
('MetaSel
('Just "column")
'NoSourceUnpackedness
'SourceStrict
'DecidedUnpack)
(K1 R Int)
:*: M1
S
('MetaSel
('Just "indentation")
'NoSourceUnpackedness
'SourceStrict
'DecidedUnpack)
(K1 R Int))>_R) <x_a7sI>_N
:: ((:*:)
(M1
S
('MetaSel
('Just "line")
'NoSourceUnpackedness
'SourceStrict
'DecidedUnpack)
(K1 R Int))
(M1
S
('MetaSel
('Just "column")
'NoSourceUnpackedness
'SourceStrict
'DecidedUnpack)
(K1 R Int)
:*: M1
S
('MetaSel
('Just "indentation")
'NoSourceUnpackedness
'SourceStrict
'DecidedUnpack)
(K1 R Int))
x_a7sI :: *)
~R# (M1
C
('MetaCons "Point" 'PrefixI 'True)
(M1
S
('MetaSel
('Just "line")
'NoSourceUnpackedness
'SourceStrict
'DecidedUnpack)
(K1 R Int)
:*: (M1
S
('MetaSel
('Just "column")
'NoSourceUnpackedness
'SourceStrict
'DecidedUnpack)
(K1 R Int)
:*: M1
S
('MetaSel
('Just "indentation")
'NoSourceUnpackedness
'SourceStrict
'DecidedUnpack)
(K1 R Int)))
x_a7sI :: *))
}}]
Main.$fGenericPoint1
= \ (@ x_a7sI) (x1_a6Tv :: Point) ->
case x1_a6Tv of { Point dt_d7Wm dt1_d7Wn dt2_d7Wo ->
(GHC.Generics.:*:
@ *
@ (M1
S
('MetaSel
('Just "line") 'NoSourceUnpackedness 'SourceStrict 'DecidedUnpack)
(K1 R Int))
@ (M1
S
('MetaSel
('Just "column")
'NoSourceUnpackedness
'SourceStrict
'DecidedUnpack)
(K1 R Int)
:*: M1
S
('MetaSel
('Just "indentation")
'NoSourceUnpackedness
'SourceStrict
'DecidedUnpack)
(K1 R Int))
@ x_a7sI
((GHC.Types.I# dt_d7Wm)
`cast` (Sym (GHC.Generics.N:K1[0]
<*>_N <R>_P <Int>_R <x_a7sI>_P) ; Sym (GHC.Generics.N:M1[0]
<*>_N
<S>_P
<'MetaSel
('Just "line")
'NoSourceUnpackedness
'SourceStrict
'DecidedUnpack>_P
<K1 R Int>_R) <x_a7sI>_N
:: (Int :: *)
~R# (M1
S
('MetaSel
('Just "line") 'NoSourceUnpackedness 'SourceStrict 'DecidedUnpack)
(K1 R Int)
x_a7sI :: *)))
(GHC.Generics.:*:
@ *
@ (M1
S
('MetaSel
('Just "column")
'NoSourceUnpackedness
'SourceStrict
'DecidedUnpack)
(K1 R Int))
@ (M1
S
('MetaSel
('Just "indentation")
'NoSourceUnpackedness
'SourceStrict
'DecidedUnpack)
(K1 R Int))
@ x_a7sI
((GHC.Types.I# dt1_d7Wn)
`cast` (Sym (GHC.Generics.N:K1[0]
<*>_N <R>_P <Int>_R <x_a7sI>_P) ; Sym (GHC.Generics.N:M1[0]
<*>_N
<S>_P
<'MetaSel
('Just "column")
'NoSourceUnpackedness
'SourceStrict
'DecidedUnpack>_P
<K1 R Int>_R) <x_a7sI>_N
:: (Int :: *)
~R# (M1
S
('MetaSel
('Just "column")
'NoSourceUnpackedness
'SourceStrict
'DecidedUnpack)
(K1 R Int)
x_a7sI :: *)))
((GHC.Types.I# dt2_d7Wo)
`cast` (Sym (GHC.Generics.N:K1[0]
<*>_N <R>_P <Int>_R <x_a7sI>_P) ; Sym (GHC.Generics.N:M1[0]
<*>_N
<S>_P
<'MetaSel
('Just "indentation")
'NoSourceUnpackedness
'SourceStrict
'DecidedUnpack>_P
<K1 R Int>_R) <x_a7sI>_N
:: (Int :: *)
~R# (M1
S
('MetaSel
('Just "indentation")
'NoSourceUnpackedness
'SourceStrict
'DecidedUnpack)
(K1 R Int)
x_a7sI :: *)))))
`cast` (Sym (GHC.Generics.N:M1[0]
<*>_N
<C>_P
<'MetaCons "Point" 'PrefixI 'True>_P
<M1
S
('MetaSel
('Just "line") 'NoSourceUnpackedness 'SourceStrict 'DecidedUnpack)
(K1 R Int)
:*: (M1
S
('MetaSel
('Just "column")
'NoSourceUnpackedness
'SourceStrict
'DecidedUnpack)
(K1 R Int)
:*: M1
S
('MetaSel
('Just "indentation")
'NoSourceUnpackedness
'SourceStrict
'DecidedUnpack)
(K1 R Int))>_R) <x_a7sI>_N
:: ((:*:)
(M1
S
('MetaSel
('Just "line") 'NoSourceUnpackedness 'SourceStrict 'DecidedUnpack)
(K1 R Int))
(M1
S
('MetaSel
('Just "column")
'NoSourceUnpackedness
'SourceStrict
'DecidedUnpack)
(K1 R Int)
:*: M1
S
('MetaSel
('Just "indentation")
'NoSourceUnpackedness
'SourceStrict
'DecidedUnpack)
(K1 R Int))
x_a7sI :: *)
~R# (M1
C
('MetaCons "Point" 'PrefixI 'True)
(M1
S
('MetaSel
('Just "line") 'NoSourceUnpackedness 'SourceStrict 'DecidedUnpack)
(K1 R Int)
:*: (M1
S
('MetaSel
('Just "column")
'NoSourceUnpackedness
'SourceStrict
'DecidedUnpack)
(K1 R Int)
:*: M1
S
('MetaSel
('Just "indentation")
'NoSourceUnpackedness
'SourceStrict
'DecidedUnpack)
(K1 R Int)))
x_a7sI :: *))
}
-- RHS size: {terms: 12, types: 182, coercions: 210, joins: 0/0}
Main.$fGenericPoint_$cto :: forall x. Rep Point x -> Point
[GblId,
Arity=1,
Caf=NoCafRefs,
Str=<S(SS(SS)),1*U(U,1*U(U,U))>m,
Unf=Unf{Src=InlineStable, TopLvl=True, Value=True, ConLike=True,
WorkFree=True, Expandable=True,
Guidance=ALWAYS_IF(arity=1,unsat_ok=True,boring_ok=False)
Tmpl= \ (@ x_a7tE) (ds_d7QB [Occ=Once] :: Rep Point x_a7tE) ->
case ds_d7QB
`cast` ((Sub (Main.Rep_Point[0]) ; (GHC.Generics.N:M1[0]
<*>_N
<D>_P
<'MetaData
"Point" "Main" "main" 'False>_P
<M1
C
('MetaCons "Point" 'PrefixI 'True)
(M1
S
('MetaSel
('Just "line")
'NoSourceUnpackedness
'SourceStrict
'DecidedUnpack)
(K1 R Int)
:*: (M1
S
('MetaSel
('Just "column")
'NoSourceUnpackedness
'SourceStrict
'DecidedUnpack)
(K1 R Int)
:*: M1
S
('MetaSel
('Just
"indentation")
'NoSourceUnpackedness
'SourceStrict
'DecidedUnpack)
(K1
R
Int)))>_R ; GHC.Generics.N:M1[0]
<*>_N
<C>_P
<'MetaCons
"Point"
'PrefixI
'True>_P
<M1
S
('MetaSel
('Just
"line")
'NoSourceUnpackedness
'SourceStrict
'DecidedUnpack)
(K1
R
Int)
:*: (M1
S
('MetaSel
('Just
"column")
'NoSourceUnpackedness
'SourceStrict
'DecidedUnpack)
(K1
R
Int)
:*: M1
S
('MetaSel
('Just
"indentation")
'NoSourceUnpackedness
'SourceStrict
'DecidedUnpack)
(K1
R
Int))>_R)) <x_a7tE>_N
:: (Rep Point x_a7tE :: *)
~R# ((:*:)
(M1
S
('MetaSel
('Just "line")
'NoSourceUnpackedness
'SourceStrict
'DecidedUnpack)
(K1 R Int))
(M1
S
('MetaSel
('Just "column")
'NoSourceUnpackedness
'SourceStrict
'DecidedUnpack)
(K1 R Int)
:*: M1
S
('MetaSel
('Just "indentation")
'NoSourceUnpackedness
'SourceStrict
'DecidedUnpack)
(K1 R Int))
x_a7tE :: *))
of
{ :*: ds1_d7QE [Occ=Once] ds2_d7QF [Occ=Once!] ->
case ds2_d7QF of { :*: ds3_d7QH [Occ=Once] ds4_d7QI [Occ=Once] ->
Main.$WPoint
(ds1_d7QE
`cast` (GHC.Generics.N:M1[0]
<*>_N
<S>_P
<'MetaSel
('Just "line")
'NoSourceUnpackedness
'SourceStrict
'DecidedUnpack>_P
<K1 R Int>_R <x_a7tE>_N ; GHC.Generics.N:K1[0]
<*>_N <R>_P <Int>_R <x_a7tE>_P
:: (M1
S
('MetaSel
('Just "line")
'NoSourceUnpackedness
'SourceStrict
'DecidedUnpack)
(K1 R Int)
x_a7tE :: *)
~R# (Int :: *)))
(ds3_d7QH
`cast` (GHC.Generics.N:M1[0]
<*>_N
<S>_P
<'MetaSel
('Just "column")
'NoSourceUnpackedness
'SourceStrict
'DecidedUnpack>_P
<K1 R Int>_R <x_a7tE>_N ; GHC.Generics.N:K1[0]
<*>_N <R>_P <Int>_R <x_a7tE>_P
:: (M1
S
('MetaSel
('Just "column")
'NoSourceUnpackedness
'SourceStrict
'DecidedUnpack)
(K1 R Int)
x_a7tE :: *)
~R# (Int :: *)))
(ds4_d7QI
`cast` (GHC.Generics.N:M1[0]
<*>_N
<S>_P
<'MetaSel
('Just "indentation")
'NoSourceUnpackedness
'SourceStrict
'DecidedUnpack>_P
<K1 R Int>_R <x_a7tE>_N ; GHC.Generics.N:K1[0]
<*>_N <R>_P <Int>_R <x_a7tE>_P
:: (M1
S
('MetaSel
('Just "indentation")
'NoSourceUnpackedness
'SourceStrict
'DecidedUnpack)
(K1 R Int)
x_a7tE :: *)
~R# (Int :: *)))
}
}}]
Main.$fGenericPoint_$cto
= \ (@ x_a7tE) (ds_d7QB :: Rep Point x_a7tE) ->
case ds_d7QB
`cast` ((Sub (Main.Rep_Point[0]) ; (GHC.Generics.N:M1[0]
<*>_N
<D>_P
<'MetaData "Point" "Main" "main" 'False>_P
<M1
C
('MetaCons "Point" 'PrefixI 'True)
(M1
S
('MetaSel
('Just "line")
'NoSourceUnpackedness
'SourceStrict
'DecidedUnpack)
(K1 R Int)
:*: (M1
S
('MetaSel
('Just "column")
'NoSourceUnpackedness
'SourceStrict
'DecidedUnpack)
(K1 R Int)
:*: M1
S
('MetaSel
('Just "indentation")
'NoSourceUnpackedness
'SourceStrict
'DecidedUnpack)
(K1
R
Int)))>_R ; GHC.Generics.N:M1[0]
<*>_N
<C>_P
<'MetaCons
"Point"
'PrefixI
'True>_P
<M1
S
('MetaSel
('Just
"line")
'NoSourceUnpackedness
'SourceStrict
'DecidedUnpack)
(K1 R Int)
:*: (M1
S
('MetaSel
('Just
"column")
'NoSourceUnpackedness
'SourceStrict
'DecidedUnpack)
(K1
R
Int)
:*: M1
S
('MetaSel
('Just
"indentation")
'NoSourceUnpackedness
'SourceStrict
'DecidedUnpack)
(K1
R
Int))>_R)) <x_a7tE>_N
:: (Rep Point x_a7tE :: *)
~R# ((:*:)
(M1
S
('MetaSel
('Just "line")
'NoSourceUnpackedness
'SourceStrict
'DecidedUnpack)
(K1 R Int))
(M1
S
('MetaSel
('Just "column")
'NoSourceUnpackedness
'SourceStrict
'DecidedUnpack)
(K1 R Int)
:*: M1
S
('MetaSel
('Just "indentation")
'NoSourceUnpackedness
'SourceStrict
'DecidedUnpack)
(K1 R Int))
x_a7tE :: *))
of
{ :*: ds1_d7QE ds2_d7QF ->
case ds2_d7QF of { :*: ds3_d7QH ds4_d7QI ->
Main.$WPoint
(ds1_d7QE
`cast` (GHC.Generics.N:M1[0]
<*>_N
<S>_P
<'MetaSel
('Just "line")
'NoSourceUnpackedness
'SourceStrict
'DecidedUnpack>_P
<K1 R Int>_R <x_a7tE>_N ; GHC.Generics.N:K1[0]
<*>_N <R>_P <Int>_R <x_a7tE>_P
:: (M1
S
('MetaSel
('Just "line") 'NoSourceUnpackedness 'SourceStrict 'DecidedUnpack)
(K1 R Int)
x_a7tE :: *)
~R# (Int :: *)))
(ds3_d7QH
`cast` (GHC.Generics.N:M1[0]
<*>_N
<S>_P
<'MetaSel
('Just "column")
'NoSourceUnpackedness
'SourceStrict
'DecidedUnpack>_P
<K1 R Int>_R <x_a7tE>_N ; GHC.Generics.N:K1[0]
<*>_N <R>_P <Int>_R <x_a7tE>_P
:: (M1
S
('MetaSel
('Just "column")
'NoSourceUnpackedness
'SourceStrict
'DecidedUnpack)
(K1 R Int)
x_a7tE :: *)
~R# (Int :: *)))
(ds4_d7QI
`cast` (GHC.Generics.N:M1[0]
<*>_N
<S>_P
<'MetaSel
('Just "indentation")
'NoSourceUnpackedness
'SourceStrict
'DecidedUnpack>_P
<K1 R Int>_R <x_a7tE>_N ; GHC.Generics.N:K1[0]
<*>_N <R>_P <Int>_R <x_a7tE>_P
:: (M1
S
('MetaSel
('Just "indentation")
'NoSourceUnpackedness
'SourceStrict
'DecidedUnpack)
(K1 R Int)
x_a7tE :: *)
~R# (Int :: *)))
}
}
-- RHS size: {terms: 3, types: 1, coercions: 81, joins: 0/0}
Main.$fGenericPoint [InlPrag=NOUSERINLINE CONLIKE] :: Generic Point
[GblId[DFunId],
Caf=NoCafRefs,
Str=m,
Unf=DFun: \ ->
GHC.Generics.C:Generic TYPE: Point
Main.$fGenericPoint1
`cast` (forall (x :: <*>_N).
<Point>_R
->_R (Sym (GHC.Generics.N:M1[0]
<*>_N
<D>_P
<'MetaData "Point" "Main" "main" 'False>_P
<M1
C
('MetaCons "Point" 'PrefixI 'True)
(M1
S
('MetaSel
('Just "line")
'NoSourceUnpackedness
'SourceStrict
'DecidedUnpack)
(K1 R Int)
:*: (M1
S
('MetaSel
('Just "column")
'NoSourceUnpackedness
'SourceStrict
'DecidedUnpack)
(K1 R Int)
:*: M1
S
('MetaSel
('Just "indentation")
'NoSourceUnpackedness
'SourceStrict
'DecidedUnpack)
(K1
R
Int)))>_R) ; Sub (Sym (Main.Rep_Point[0]))) <x>_N
:: (forall x.
Point
-> M1
C
('MetaCons "Point" 'PrefixI 'True)
(M1
S
('MetaSel
('Just "line")
'NoSourceUnpackedness
'SourceStrict
'DecidedUnpack)
(K1 R Int)
:*: (M1
S
('MetaSel
('Just "column")
'NoSourceUnpackedness
'SourceStrict
'DecidedUnpack)
(K1 R Int)
:*: M1
S
('MetaSel
('Just "indentation")
'NoSourceUnpackedness
'SourceStrict
'DecidedUnpack)
(K1 R Int)))
x :: *)
~R# (forall x. Point -> Rep Point x :: *))
Main.$fGenericPoint_$cto]
Main.$fGenericPoint
= GHC.Generics.C:Generic
@ Point
(Main.$fGenericPoint1
`cast` (forall (x :: <*>_N).
<Point>_R
->_R (Sym (GHC.Generics.N:M1[0]
<*>_N
<D>_P
<'MetaData "Point" "Main" "main" 'False>_P
<M1
C
('MetaCons "Point" 'PrefixI 'True)
(M1
S
('MetaSel
('Just "line")
'NoSourceUnpackedness
'SourceStrict
'DecidedUnpack)
(K1 R Int)
:*: (M1
S
('MetaSel
('Just "column")
'NoSourceUnpackedness
'SourceStrict
'DecidedUnpack)
(K1 R Int)
:*: M1
S
('MetaSel
('Just "indentation")
'NoSourceUnpackedness
'SourceStrict
'DecidedUnpack)
(K1 R Int)))>_R) ; Sub (Sym (Main.Rep_Point[0]))) <x>_N
:: (forall x.
Point
-> M1
C
('MetaCons "Point" 'PrefixI 'True)
(M1
S
('MetaSel
('Just "line") 'NoSourceUnpackedness 'SourceStrict 'DecidedUnpack)
(K1 R Int)
:*: (M1
S
('MetaSel
('Just "column")
'NoSourceUnpackedness
'SourceStrict
'DecidedUnpack)
(K1 R Int)
:*: M1
S
('MetaSel
('Just "indentation")
'NoSourceUnpackedness
'SourceStrict
'DecidedUnpack)
(K1 R Int)))
x :: *)
~R# (forall x. Point -> Rep Point x :: *)))
Main.$fGenericPoint_$cto
-- RHS size: {terms: 7, types: 17, coercions: 0, joins: 0/0}
Main.$fFunctorP2
:: forall (m :: * -> *).
Monad m =>
forall a b.
(a -> b) -> ZeptoT (StateT Point m) a -> ZeptoT (StateT Point m) b
[GblId,
Arity=1,
Caf=NoCafRefs,
Str=<L,U(U(U(C(C1(U)),A),A,A,A,A,A),C(C1(U)),A,C(U),C(U))>,
Unf=Unf{Src=InlineStable, TopLvl=True, Value=True, ConLike=True,
WorkFree=True, Expandable=True,
Guidance=ALWAYS_IF(arity=1,unsat_ok=True,boring_ok=False)
Tmpl= \ (@ (m_X7wZ :: * -> *))
($dMonad_X7x1 [Occ=Once] :: Monad m_X7wZ)
(@ a_a7uA)
(@ b_a7uB) ->
Zepto.$fFunctorZeptoT_$cfmap
@ (StateT Point m_X7wZ)
(Control.Monad.Trans.State.Strict.$fMonadStateT
@ m_X7wZ @ Point $dMonad_X7x1)
@ a_a7uA
@ b_a7uB}]
Main.$fFunctorP2
= \ (@ (m_X7wZ :: * -> *))
($dMonad_X7x1 :: Monad m_X7wZ)
(@ a_a7uA)
(@ b_a7uB) ->
Zepto.$fFunctorZeptoT_$cfmap
@ (StateT Point m_X7wZ)
(Control.Monad.Trans.State.Strict.$fMonadStateT
@ m_X7wZ @ Point $dMonad_X7x1)
@ a_a7uA
@ b_a7uB
-- RHS size: {terms: 47, types: 87, coercions: 16, joins: 0/3}
Main.$fFunctorP1
:: forall (m :: * -> *).
Monad m =>
forall a b.
a
-> ZeptoT (StateT Point m) b
-> Zepto.S
-> StateT Point m (Zepto.Result a)
[GblId,
Arity=4,
Caf=NoCafRefs,
Str=<L,U(A,C(C1(U)),A,C(U),A)><L,U><L,1*C1(C(U))><L,U>,
Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
WorkFree=True, Expandable=True,
Guidance=IF_ARGS [90 20 60 0] 320 60}]
Main.$fFunctorP1
= \ (@ (m_a7uv :: * -> *))
($dMonad_a7uw :: Monad m_a7uv)
(@ a_a7v4)
(@ b_a7v5)
(x_i85G :: a_a7v4)
(eta_i85H :: ZeptoT (StateT Point m_a7uv) b_a7v5)
(eta1_i85I :: Zepto.S) ->
let {
$wlvl_sbJr [InlPrag=NOUSERINLINE[0], Dmd=<L,C(C1(U))>]
:: Zepto.Result b_a7v5
-> Point -> m_a7uv (Zepto.Result a_a7v4, Point)
[LclId, Arity=2, Str=<S,1*U><L,U>, Unf=OtherCon []]
$wlvl_sbJr
= \ (ww_sbJo :: Zepto.Result b_a7v5) (ww1_sbJp :: Point) ->
case ww_sbJo of {
Zepto.Fail err_i85M ->
return
@ m_a7uv
$dMonad_a7uw
@ (Zepto.Result a_a7v4, Point)
(Zepto.Fail @ a_a7v4 err_i85M, ww1_sbJp);
Zepto.OK a1_i85P s'_i85Q ->
return
@ m_a7uv
$dMonad_a7uw
@ (Zepto.Result a_a7v4, Point)
(case x_i85G of dt_i85S { __DEFAULT ->
Zepto.OK @ a_a7v4 dt_i85S s'_i85Q
},
ww1_sbJp)
} } in
let {
lvl12_samn [InlPrag=NOUSERINLINE[0]]
:: (Zepto.Result b_a7v5, Point)
-> m_a7uv (Zepto.Result a_a7v4, Point)
[LclId,
Arity=1,
Str=<S(SL),1*U(1*U,U)>,
Unf=Unf{Src=InlineStable, TopLvl=False, Value=True, ConLike=True,
WorkFree=True, Expandable=True,
Guidance=ALWAYS_IF(arity=1,unsat_ok=True,boring_ok=False)
Tmpl= \ (w_sbJl [Occ=Once!] :: (Zepto.Result b_a7v5, Point)) ->
case w_sbJl of { (ww1_sbJo [Occ=Once], ww2_sbJp [Occ=Once]) ->
$wlvl_sbJr ww1_sbJo ww2_sbJp
}}]
lvl12_samn
= \ (w_sbJl :: (Zepto.Result b_a7v5, Point)) ->
case w_sbJl of { (ww1_sbJo, ww2_sbJp) ->
$wlvl_sbJr ww1_sbJo ww2_sbJp
} } in
let {
m1_saiP [Dmd=<L,C(U)>] :: StateT Point m_a7uv (Zepto.Result b_a7v5)
[LclId]
m1_saiP
= (eta_i85H
`cast` (Zepto.N:ZeptoT[0] <StateT Point m_a7uv>_R <b_a7v5>_N
:: (ZeptoT (StateT Point m_a7uv) b_a7v5 :: *)
~R# (Zepto.S -> StateT Point m_a7uv (Zepto.Result b_a7v5) :: *)))
eta1_i85I } in
(\ (s1_a84j :: Point) ->
>>=
@ m_a7uv
$dMonad_a7uw
@ (Zepto.Result b_a7v5, Point)
@ (Zepto.Result a_a7v4, Point)
((m1_saiP
`cast` (Control.Monad.Trans.State.Strict.N:StateT[0]
<Point>_N <m_a7uv>_R <Zepto.Result b_a7v5>_N
:: (StateT Point m_a7uv (Zepto.Result b_a7v5) :: *)
~R# (Point -> m_a7uv (Zepto.Result b_a7v5, Point) :: *)))
s1_a84j)
lvl12_samn)
`cast` (Sym (Control.Monad.Trans.State.Strict.N:StateT[0]
<Point>_N <m_a7uv>_R <Zepto.Result a_a7v4>_N)
:: (Point -> m_a7uv (Zepto.Result a_a7v4, Point) :: *)
~R# (StateT Point m_a7uv (Zepto.Result a_a7v4) :: *))
-- RHS size: {terms: 7, types: 10, coercions: 42, joins: 0/0}
Main.$fFunctorP [InlPrag=NOUSERINLINE CONLIKE]
:: forall (m :: * -> *). Monad m => Functor (P m)
[GblId[DFunId],
Arity=1,
Caf=NoCafRefs,
Str=<L,U(U(U(C(C1(U)),A),A,A,A,A,A),C(C1(U)),A,C(U),C(U))>m,
Unf=DFun: \ (@ (m_a4AL :: * -> *)) (v_X5G :: Monad m_a4AL) ->
GHC.Base.C:Functor TYPE: P m_a4AL
(Main.$fFunctorP2 @ m_a4AL v_X5G)
`cast` (forall (a :: <*>_N) (b :: <*>_N).
<a -> b>_R
->_R Sym (Main.N:P[0] <m_a4AL>_R) <a>_N
->_R Sym (Main.N:P[0] <m_a4AL>_R) <b>_N
:: (forall a b.
(a -> b)
-> ZeptoT (StateT Point m_a4AL) a
-> ZeptoT (StateT Point m_a4AL) b :: *)
~R# (forall a b. (a -> b) -> P m_a4AL a -> P m_a4AL b :: *))
(Main.$fFunctorP1 @ m_a4AL v_X5G)
`cast` (forall (a :: <*>_N) (b :: <*>_N).
<a>_R
->_R Sym (Main.N:P[0] <m_a4AL>_R) <b>_N
->_R Sym (Zepto.N:ZeptoT[0]
<StateT Point m_a4AL>_R <a>_N) ; Sym (Main.N:P[0]
<m_a4AL>_R) <a>_N
:: (forall a b.
a
-> ZeptoT (StateT Point m_a4AL) b
-> Zepto.S
-> StateT Point m_a4AL (Zepto.Result a) :: *)
~R# (forall a b. a -> P m_a4AL b -> P m_a4AL a :: *))]
Main.$fFunctorP
= \ (@ (m_X7xi :: * -> *)) ($dMonad_X7xk :: Monad m_X7xi) ->
GHC.Base.C:Functor
@ (P m_X7xi)
((Main.$fFunctorP2 @ m_X7xi $dMonad_X7xk)
`cast` (forall (a :: <*>_N) (b :: <*>_N).
<a -> b>_R
->_R Sym (Main.N:P[0] <m_X7xi>_R) <a>_N
->_R Sym (Main.N:P[0] <m_X7xi>_R) <b>_N
:: (forall a b.
(a -> b)
-> ZeptoT (StateT Point m_X7xi) a
-> ZeptoT (StateT Point m_X7xi) b :: *)
~R# (forall a b. (a -> b) -> P m_X7xi a -> P m_X7xi b :: *)))
((Main.$fFunctorP1 @ m_X7xi $dMonad_X7xk)
`cast` (forall (a :: <*>_N) (b :: <*>_N).
<a>_R
->_R Sym (Main.N:P[0] <m_X7xi>_R) <b>_N
->_R Sym (Zepto.N:ZeptoT[0]
<StateT Point m_X7xi>_R <a>_N) ; Sym (Main.N:P[0] <m_X7xi>_R) <a>_N
:: (forall a b.
a
-> ZeptoT (StateT Point m_X7xi) b
-> Zepto.S
-> StateT Point m_X7xi (Zepto.Result a) :: *)
~R# (forall a b. a -> P m_X7xi b -> P m_X7xi a :: *)))
-- RHS size: {terms: 6, types: 14, coercions: 0, joins: 0/0}
Main.$fApplicativeP5
:: forall (m :: * -> *).
Monad m =>
forall a. a -> ZeptoT (StateT Point m) a
[GblId,
Arity=1,
Caf=NoCafRefs,
Str=<L,U(U(U(C(C1(U)),A),A,A,A,A,A),C(C1(U)),A,C(U),C(U))>,
Unf=Unf{Src=InlineStable, TopLvl=True, Value=True, ConLike=True,
WorkFree=True, Expandable=True,
Guidance=ALWAYS_IF(arity=1,unsat_ok=True,boring_ok=False)
Tmpl= \ (@ (m_X7y4 :: * -> *))
($dMonad_X7y6 [Occ=Once] :: Monad m_X7y4)
(@ a_a7vC) ->
Zepto.$fApplicativeZeptoT_$cpure
@ (StateT Point m_X7y4)
(Control.Monad.Trans.State.Strict.$fMonadStateT
@ m_X7y4 @ Point $dMonad_X7y6)
@ a_a7vC}]
Main.$fApplicativeP5
= \ (@ (m_X7y4 :: * -> *))
($dMonad_X7y6 :: Monad m_X7y4)
(@ a_a7vC) ->
Zepto.$fApplicativeZeptoT_$cpure
@ (StateT Point m_X7y4)
(Control.Monad.Trans.State.Strict.$fMonadStateT
@ m_X7y4 @ Point $dMonad_X7y6)
@ a_a7vC
-- RHS size: {terms: 67, types: 136, coercions: 28, joins: 0/3}
Main.$fApplicativeP4
:: forall (m :: * -> *).
Monad m =>
forall a b.
ZeptoT (StateT Point m) (a -> b)
-> ZeptoT (StateT Point m) a
-> Zepto.S
-> StateT Point m (Zepto.Result b)
[GblId,
Arity=4,
Caf=NoCafRefs,
Str=<L,U(A,C(C1(U)),A,C(U),A)><L,1*C1(C(U))><L,C(C1(U))><L,U>,
Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
WorkFree=True, Expandable=True,
Guidance=IF_ARGS [150 60 60 0] 500 60}]
Main.$fApplicativeP4
= \ (@ (m_X7y3 :: * -> *))
($dMonad_X7y5 :: Monad m_X7y3)
(@ a_a7vU)
(@ b_a7vV)
(m1_i859 :: ZeptoT (StateT Point m_X7y3) (a_a7vU -> b_a7vV))
(m2_i85a :: ZeptoT (StateT Point m_X7y3) a_a7vU)
(s_i85b :: Zepto.S) ->
let {
$wlvl_sbJF [InlPrag=NOUSERINLINE[0], Dmd=<L,C(C1(U))>]
:: Zepto.Result (a_a7vU -> b_a7vV)
-> Point -> m_X7y3 (Zepto.Result b_a7vV, Point)
[LclId, Arity=2, Str=<S,1*U><L,U>, Unf=OtherCon []]
$wlvl_sbJF
= \ (ww_sbJC :: Zepto.Result (a_a7vU -> b_a7vV))
(ww1_sbJD :: Point) ->
case ww_sbJC of {
Zepto.Fail err_i85f ->
return
@ m_X7y3
$dMonad_X7y5
@ (Zepto.Result b_a7vV, Point)
(Zepto.Fail @ b_a7vV err_i85f, ww1_sbJD);
Zepto.OK a1_i85i s'_i85j ->
>>=
@ m_X7y3
$dMonad_X7y5
@ (Zepto.Result a_a7vU, Point)
@ (Zepto.Result b_a7vV, Point)
((((m2_i85a
`cast` (Zepto.N:ZeptoT[0] <StateT Point m_X7y3>_R <a_a7vU>_N
:: (ZeptoT (StateT Point m_X7y3) a_a7vU :: *)
~R# (Zepto.S -> StateT Point m_X7y3 (Zepto.Result a_a7vU) :: *)))
s'_i85j)
`cast` (Control.Monad.Trans.State.Strict.N:StateT[0]
<Point>_N <m_X7y3>_R <Zepto.Result a_a7vU>_N
:: (StateT Point m_X7y3 (Zepto.Result a_a7vU) :: *)
~R# (Point -> m_X7y3 (Zepto.Result a_a7vU, Point) :: *)))
ww1_sbJD)
(\ (ds_X87o :: (Zepto.Result a_a7vU, Point)) ->
case ds_X87o of { (a2_X87u, s'1_X87w) ->
case a2_X87u of {
Zepto.Fail err_i85o ->
return
@ m_X7y3
$dMonad_X7y5
@ (Zepto.Result b_a7vV, Point)
(Zepto.Fail @ b_a7vV err_i85o, s'1_X87w);
Zepto.OK a3_i85r s'2_i85s ->
return
@ m_X7y3
$dMonad_X7y5
@ (Zepto.Result b_a7vV, Point)
(case a1_i85i a3_i85r of dt_X7RU { __DEFAULT ->
Zepto.OK @ b_a7vV dt_X7RU s'2_i85s
},
s'1_X87w)
}
})
} } in
let {
lvl12_saml [InlPrag=NOUSERINLINE[0]]
:: (Zepto.Result (a_a7vU -> b_a7vV), Point)
-> m_X7y3 (Zepto.Result b_a7vV, Point)
[LclId,
Arity=1,
Str=<S(SL),1*U(1*U,U)>,
Unf=Unf{Src=InlineStable, TopLvl=False, Value=True, ConLike=True,
WorkFree=True, Expandable=True,
Guidance=ALWAYS_IF(arity=1,unsat_ok=True,boring_ok=False)
Tmpl= \ (w_sbJz [Occ=Once!]
:: (Zepto.Result (a_a7vU -> b_a7vV), Point)) ->
case w_sbJz of { (ww1_sbJC [Occ=Once], ww2_sbJD [Occ=Once]) ->
$wlvl_sbJF ww1_sbJC ww2_sbJD
}}]
lvl12_saml
= \ (w_sbJz :: (Zepto.Result (a_a7vU -> b_a7vV), Point)) ->
case w_sbJz of { (ww1_sbJC, ww2_sbJD) ->
$wlvl_sbJF ww1_sbJC ww2_sbJD
} } in
let {
m4_saiV [Dmd=<L,C(U)>]
:: StateT Point m_X7y3 (Zepto.Result (a_a7vU -> b_a7vV))
[LclId]
m4_saiV
= (m1_i859
`cast` (Zepto.N:ZeptoT[0]
<StateT Point m_X7y3>_R <a_a7vU -> b_a7vV>_N
:: (ZeptoT (StateT Point m_X7y3) (a_a7vU -> b_a7vV) :: *)
~R# (Zepto.S
-> StateT Point m_X7y3 (Zepto.Result (a_a7vU -> b_a7vV)) :: *)))
s_i85b } in
(\ (s1_a84j :: Point) ->
>>=
@ m_X7y3
$dMonad_X7y5
@ (Zepto.Result (a_a7vU -> b_a7vV), Point)
@ (Zepto.Result b_a7vV, Point)
((m4_saiV
`cast` (Control.Monad.Trans.State.Strict.N:StateT[0]
<Point>_N <m_X7y3>_R <Zepto.Result (a_a7vU -> b_a7vV)>_N
:: (StateT Point m_X7y3 (Zepto.Result (a_a7vU -> b_a7vV)) :: *)
~R# (Point
-> m_X7y3 (Zepto.Result (a_a7vU -> b_a7vV), Point) :: *)))
s1_a84j)
lvl12_saml)
`cast` (Sym (Control.Monad.Trans.State.Strict.N:StateT[0]
<Point>_N <m_X7y3>_R <Zepto.Result b_a7vV>_N)
:: (Point -> m_X7y3 (Zepto.Result b_a7vV, Point) :: *)
~R# (StateT Point m_X7y3 (Zepto.Result b_a7vV) :: *))
-- RHS size: {terms: 8, types: 20, coercions: 0, joins: 0/0}
Main.$fApplicativeP3
:: forall (m :: * -> *).
Monad m =>
forall a b c.
(a -> b -> c)
-> ZeptoT (StateT Point m) a
-> ZeptoT (StateT Point m) b
-> Zepto.S
-> StateT Point m (Zepto.Result c)
[GblId,
Arity=1,
Caf=NoCafRefs,
Str=<L,U(U(U(C(C1(U)),A),A,A,A,A,A),C(C1(U)),A,C(U),C(U))>,
Unf=Unf{Src=InlineStable, TopLvl=True, Value=True, ConLike=True,
WorkFree=True, Expandable=True,
Guidance=ALWAYS_IF(arity=1,unsat_ok=True,boring_ok=False)
Tmpl= \ (@ (m_X7xW :: * -> *))
($dMonad_X7xY [Occ=Once] :: Monad m_X7xW)
(@ a_a7wo)
(@ b_a7wp)
(@ c_a7wq) ->
Zepto.$fAlternativeZeptoT2
@ (StateT Point m_X7xW)
(Control.Monad.Trans.State.Strict.$fMonadStateT
@ m_X7xW @ Point $dMonad_X7xY)
@ a_a7wo
@ b_a7wp
@ c_a7wq}]
Main.$fApplicativeP3
= \ (@ (m_X7xW :: * -> *))
($dMonad_X7xY :: Monad m_X7xW)
(@ a_a7wo)
(@ b_a7wp)
(@ c_a7wq) ->
Zepto.$fAlternativeZeptoT2
@ (StateT Point m_X7xW)
(Control.Monad.Trans.State.Strict.$fMonadStateT
@ m_X7xW @ Point $dMonad_X7xY)
@ a_a7wo
@ b_a7wp
@ c_a7wq
-- RHS size: {terms: 7, types: 17, coercions: 0, joins: 0/0}
Main.$fApplicativeP2
:: forall (m :: * -> *).
Monad m =>
forall a b.
ZeptoT (StateT Point m) a
-> ZeptoT (StateT Point m) b
-> Zepto.S
-> StateT Point m (Zepto.Result b)
[GblId,
Arity=1,
Caf=NoCafRefs,
Str=<L,U(U(U(C(C1(U)),A),A,A,A,A,A),C(C1(U)),A,C(U),C(U))>,
Unf=Unf{Src=InlineStable, TopLvl=True, Value=True, ConLike=True,
WorkFree=True, Expandable=True,
Guidance=ALWAYS_IF(arity=1,unsat_ok=True,boring_ok=False)
Tmpl= \ (@ (m_X7xI :: * -> *))
($dMonad_X7xK [Occ=Once] :: Monad m_X7xI)
(@ a_a7x4)
(@ b_a7x5) ->
Zepto.$fApplicativeZeptoT2
@ (StateT Point m_X7xI)
(Control.Monad.Trans.State.Strict.$fMonadStateT
@ m_X7xI @ Point $dMonad_X7xK)
@ a_a7x4
@ b_a7x5}]
Main.$fApplicativeP2
= \ (@ (m_X7xI :: * -> *))
($dMonad_X7xK :: Monad m_X7xI)
(@ a_a7x4)
(@ b_a7x5) ->
Zepto.$fApplicativeZeptoT2
@ (StateT Point m_X7xI)
(Control.Monad.Trans.State.Strict.$fMonadStateT
@ m_X7xI @ Point $dMonad_X7xK)
@ a_a7x4
@ b_a7x5
-- RHS size: {terms: 99, types: 207, coercions: 26, joins: 0/5}
Main.$fApplicativeP1
:: forall (m :: * -> *).
Monad m =>
forall a b.
ZeptoT (StateT Point m) a
-> ZeptoT (StateT Point m) b
-> Zepto.S
-> StateT Point m (Zepto.Result a)
[GblId,
Arity=4,
Caf=NoCafRefs,
Str=<L,U(A,C(C1(U)),A,C(U),A)><L,1*C1(C(U))><L,C(C1(U))><L,U>,
Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
WorkFree=True, Expandable=True,
Guidance=IF_ARGS [240 60 60 0] 760 60}]
Main.$fApplicativeP1
= \ (@ (m_a7vt :: * -> *))
($dMonad_a7vu :: Monad m_a7vt)
(@ a_a7xu)
(@ b_a7xv)
(x_i83C :: ZeptoT (StateT Point m_a7vt) a_a7xu)
(eta_i83D :: ZeptoT (StateT Point m_a7vt) b_a7xv)
(eta1_i83E :: Zepto.S) ->
let {
$wlvl_sbKk [InlPrag=NOUSERINLINE[0], Dmd=<L,C(C1(U))>]
:: Zepto.Result a_a7xu
-> Point -> m_a7vt (Zepto.Result (b_a7xv -> a_a7xu), Point)
[LclId, Arity=2, Str=<S,1*U><L,U>, Unf=OtherCon []]
$wlvl_sbKk
= \ (ww_sbKh :: Zepto.Result a_a7xu) (ww1_sbKi :: Point) ->
case ww_sbKh of {
Zepto.Fail err_i83I ->
return
@ m_a7vt
$dMonad_a7vu
@ (Zepto.Result (b_a7xv -> a_a7xu), Point)
(Zepto.Fail @ (b_a7xv -> a_a7xu) err_i83I, ww1_sbKi);
Zepto.OK a1_i83L s'_i83M ->
return
@ m_a7vt
$dMonad_a7vu
@ (Zepto.Result (b_a7xv -> a_a7xu), Point)
(Zepto.OK @ (b_a7xv -> a_a7xu) (\ _ [Occ=Dead] -> a1_i83L) s'_i83M,
ww1_sbKi)
} } in
let {
lvl12_samj [InlPrag=NOUSERINLINE[0]]
:: (Zepto.Result a_a7xu, Point)
-> m_a7vt (Zepto.Result (b_a7xv -> a_a7xu), Point)
[LclId,
Arity=1,
Str=<S(SL),1*U(1*U,U)>,
Unf=Unf{Src=InlineStable, TopLvl=False, Value=True, ConLike=True,
WorkFree=True, Expandable=True,
Guidance=ALWAYS_IF(arity=1,unsat_ok=True,boring_ok=False)
Tmpl= \ (w_sbKe [Occ=Once!] :: (Zepto.Result a_a7xu, Point)) ->
case w_sbKe of { (ww1_sbKh [Occ=Once], ww2_sbKi [Occ=Once]) ->
$wlvl_sbKk ww1_sbKh ww2_sbKi
}}]
lvl12_samj
= \ (w_sbKe :: (Zepto.Result a_a7xu, Point)) ->
case w_sbKe of { (ww1_sbKh, ww2_sbKi) ->
$wlvl_sbKk ww1_sbKh ww2_sbKi
} } in
let {
$wlvl1_sbKd [InlPrag=NOUSERINLINE[0], Dmd=<L,C(C1(U))>]
:: Zepto.Result (b_a7xv -> a_a7xu)
-> Point -> m_a7vt (Zepto.Result a_a7xu, Point)
[LclId, Arity=2, Str=<S,1*U><L,U>, Unf=OtherCon []]
$wlvl1_sbKd
= \ (ww_sbKa :: Zepto.Result (b_a7xv -> a_a7xu))
(ww1_sbKb :: Point) ->
case ww_sbKa of {
Zepto.Fail err_i83S ->
return
@ m_a7vt
$dMonad_a7vu
@ (Zepto.Result a_a7xu, Point)
(Zepto.Fail @ a_a7xu err_i83S, ww1_sbKb);
Zepto.OK a1_i83V s'_i83W ->
>>=
@ m_a7vt
$dMonad_a7vu
@ (Zepto.Result b_a7xv, Point)
@ (Zepto.Result a_a7xu, Point)
((((eta_i83D
`cast` (Zepto.N:ZeptoT[0] <StateT Point m_a7vt>_R <b_a7xv>_N
:: (ZeptoT (StateT Point m_a7vt) b_a7xv :: *)
~R# (Zepto.S -> StateT Point m_a7vt (Zepto.Result b_a7xv) :: *)))
s'_i83W)
`cast` (Control.Monad.Trans.State.Strict.N:StateT[0]
<Point>_N <m_a7vt>_R <Zepto.Result b_a7xv>_N
:: (StateT Point m_a7vt (Zepto.Result b_a7xv) :: *)
~R# (Point -> m_a7vt (Zepto.Result b_a7xv, Point) :: *)))
ww1_sbKb)
(\ (ds_X87f :: (Zepto.Result b_a7xv, Point)) ->
case ds_X87f of { (a2_X87l, s'1_X87n) ->
case a2_X87l of {
Zepto.Fail err_i841 ->
return
@ m_a7vt
$dMonad_a7vu
@ (Zepto.Result a_a7xu, Point)
(Zepto.Fail @ a_a7xu err_i841, s'1_X87n);
Zepto.OK a3_i844 s'2_i845 ->
return
@ m_a7vt
$dMonad_a7vu
@ (Zepto.Result a_a7xu, Point)
(case a1_i83V a3_i844 of dt_i847 { __DEFAULT ->
Zepto.OK @ a_a7xu dt_i847 s'2_i845
},
s'1_X87n)
}
})
} } in
let {
lvl13_samk [InlPrag=NOUSERINLINE[0]]
:: (Zepto.Result (b_a7xv -> a_a7xu), Point)
-> m_a7vt (Zepto.Result a_a7xu, Point)
[LclId,
Arity=1,
Str=<S(SL),1*U(1*U,U)>,
Unf=Unf{Src=InlineStable, TopLvl=False, Value=True, ConLike=True,
WorkFree=True, Expandable=True,
Guidance=ALWAYS_IF(arity=1,unsat_ok=True,boring_ok=False)
Tmpl= \ (w_sbK7 [Occ=Once!]
:: (Zepto.Result (b_a7xv -> a_a7xu), Point)) ->
case w_sbK7 of { (ww1_sbKa [Occ=Once], ww2_sbKb [Occ=Once]) ->
$wlvl1_sbKd ww1_sbKa ww2_sbKb
}}]
lvl13_samk
= \ (w_sbK7 :: (Zepto.Result (b_a7xv -> a_a7xu), Point)) ->
case w_sbK7 of { (ww1_sbKa, ww2_sbKb) ->
$wlvl1_sbKd ww1_sbKa ww2_sbKb
} } in
let {
m1_saiX [Dmd=<L,C(U)>] :: StateT Point m_a7vt (Zepto.Result a_a7xu)
[LclId]
m1_saiX
= (x_i83C
`cast` (Zepto.N:ZeptoT[0] <StateT Point m_a7vt>_R <a_a7xu>_N
:: (ZeptoT (StateT Point m_a7vt) a_a7xu :: *)
~R# (Zepto.S -> StateT Point m_a7vt (Zepto.Result a_a7xu) :: *)))
eta1_i83E } in
(\ (s1_X86W :: Point) ->
>>=
@ m_a7vt
$dMonad_a7vu
@ (Zepto.Result (b_a7xv -> a_a7xu), Point)
@ (Zepto.Result a_a7xu, Point)
(>>=
@ m_a7vt
$dMonad_a7vu
@ (Zepto.Result a_a7xu, Point)
@ (Zepto.Result (b_a7xv -> a_a7xu), Point)
((m1_saiX
`cast` (Control.Monad.Trans.State.Strict.N:StateT[0]
<Point>_N <m_a7vt>_R <Zepto.Result a_a7xu>_N
:: (StateT Point m_a7vt (Zepto.Result a_a7xu) :: *)
~R# (Point -> m_a7vt (Zepto.Result a_a7xu, Point) :: *)))
s1_X86W)
lvl12_samj)
lvl13_samk)
`cast` (Sym (Control.Monad.Trans.State.Strict.N:StateT[0]
<Point>_N <m_a7vt>_R <Zepto.Result a_a7xu>_N)
:: (Point -> m_a7vt (Zepto.Result a_a7xu, Point) :: *)
~R# (StateT Point m_a7vt (Zepto.Result a_a7xu) :: *))
-- RHS size: {terms: 15, types: 14, coercions: 125, joins: 0/0}
Main.$fApplicativeP [InlPrag=NOUSERINLINE CONLIKE]
:: forall (m :: * -> *). Monad m => Applicative (P m)
[GblId[DFunId],
Arity=1,
Caf=NoCafRefs,
Str=<L,U(U(U(C(C1(U)),A),A,A,A,A,A),C(C1(U)),A,C(U),C(U))>m,
Unf=DFun: \ (@ (m_a4AL :: * -> *)) (v_X5P :: Monad m_a4AL) ->
GHC.Base.C:Applicative TYPE: P m_a4AL
Main.$fFunctorP @ m_a4AL v_X5P
(Main.$fApplicativeP5 @ m_a4AL v_X5P)
`cast` (forall (a :: <*>_N).
<a>_R ->_R Sym (Main.N:P[0] <m_a4AL>_R) <a>_N
:: (forall a. a -> ZeptoT (StateT Point m_a4AL) a :: *)
~R# (forall a. a -> P m_a4AL a :: *))
(Main.$fApplicativeP4 @ m_a4AL v_X5P)
`cast` (forall (a :: <*>_N) (b :: <*>_N).
Sym (Main.N:P[0] <m_a4AL>_R) <a -> b>_N
->_R Sym (Main.N:P[0] <m_a4AL>_R) <a>_N
->_R Sym (Zepto.N:ZeptoT[0]
<StateT Point m_a4AL>_R
<b>_N) ; Sym (Main.N:P[0] <m_a4AL>_R) <b>_N
:: (forall a b.
ZeptoT (StateT Point m_a4AL) (a -> b)
-> ZeptoT (StateT Point m_a4AL) a
-> Zepto.S
-> StateT Point m_a4AL (Zepto.Result b) :: *)
~R# (forall a b.
P m_a4AL (a -> b) -> P m_a4AL a -> P m_a4AL b :: *))
(Main.$fApplicativeP3 @ m_a4AL v_X5P)
`cast` (forall (a :: <*>_N) (b :: <*>_N) (c :: <*>_N).
<a -> b -> c>_R
->_R Sym (Main.N:P[0] <m_a4AL>_R) <a>_N
->_R Sym (Main.N:P[0] <m_a4AL>_R) <b>_N
->_R Sym (Zepto.N:ZeptoT[0]
<StateT Point m_a4AL>_R
<c>_N) ; Sym (Main.N:P[0] <m_a4AL>_R) <c>_N
:: (forall a b c.
(a -> b -> c)
-> ZeptoT (StateT Point m_a4AL) a
-> ZeptoT (StateT Point m_a4AL) b
-> Zepto.S
-> StateT Point m_a4AL (Zepto.Result c) :: *)
~R# (forall a b c.
(a -> b -> c)
-> P m_a4AL a -> P m_a4AL b -> P m_a4AL c :: *))
(Main.$fApplicativeP2 @ m_a4AL v_X5P)
`cast` (forall (a :: <*>_N) (b :: <*>_N).
Sym (Main.N:P[0] <m_a4AL>_R) <a>_N
->_R Sym (Main.N:P[0] <m_a4AL>_R) <b>_N
->_R Sym (Zepto.N:ZeptoT[0]
<StateT Point m_a4AL>_R
<b>_N) ; Sym (Main.N:P[0] <m_a4AL>_R) <b>_N
:: (forall a b.
ZeptoT (StateT Point m_a4AL) a
-> ZeptoT (StateT Point m_a4AL) b
-> Zepto.S
-> StateT Point m_a4AL (Zepto.Result b) :: *)
~R# (forall a b.
P m_a4AL a -> P m_a4AL b -> P m_a4AL b :: *))
(Main.$fApplicativeP1 @ m_a4AL v_X5P)
`cast` (forall (a :: <*>_N) (b :: <*>_N).
Sym (Main.N:P[0] <m_a4AL>_R) <a>_N
->_R Sym (Main.N:P[0] <m_a4AL>_R) <b>_N
->_R Sym (Zepto.N:ZeptoT[0]
<StateT Point m_a4AL>_R
<a>_N) ; Sym (Main.N:P[0] <m_a4AL>_R) <a>_N
:: (forall a b.
ZeptoT (StateT Point m_a4AL) a
-> ZeptoT (StateT Point m_a4AL) b
-> Zepto.S
-> StateT Point m_a4AL (Zepto.Result a) :: *)
~R# (forall a b.
P m_a4AL a -> P m_a4AL b -> P m_a4AL a :: *))]
Main.$fApplicativeP
= \ (@ (m_X7yh :: * -> *)) ($dMonad_X7yj :: Monad m_X7yh) ->
GHC.Base.C:Applicative
@ (P m_X7yh)
(Main.$fFunctorP @ m_X7yh $dMonad_X7yj)
((Main.$fApplicativeP5 @ m_X7yh $dMonad_X7yj)
`cast` (forall (a :: <*>_N).
<a>_R ->_R Sym (Main.N:P[0] <m_X7yh>_R) <a>_N
:: (forall a. a -> ZeptoT (StateT Point m_X7yh) a :: *)
~R# (forall a. a -> P m_X7yh a :: *)))
((Main.$fApplicativeP4 @ m_X7yh $dMonad_X7yj)
`cast` (forall (a :: <*>_N) (b :: <*>_N).
Sym (Main.N:P[0] <m_X7yh>_R) <a -> b>_N
->_R Sym (Main.N:P[0] <m_X7yh>_R) <a>_N
->_R Sym (Zepto.N:ZeptoT[0]
<StateT Point m_X7yh>_R <b>_N) ; Sym (Main.N:P[0] <m_X7yh>_R) <b>_N
:: (forall a b.
ZeptoT (StateT Point m_X7yh) (a -> b)
-> ZeptoT (StateT Point m_X7yh) a
-> Zepto.S
-> StateT Point m_X7yh (Zepto.Result b) :: *)
~R# (forall a b.
P m_X7yh (a -> b) -> P m_X7yh a -> P m_X7yh b :: *)))
((Main.$fApplicativeP3 @ m_X7yh $dMonad_X7yj)
`cast` (forall (a :: <*>_N) (b :: <*>_N) (c :: <*>_N).
<a -> b -> c>_R
->_R Sym (Main.N:P[0] <m_X7yh>_R) <a>_N
->_R Sym (Main.N:P[0] <m_X7yh>_R) <b>_N
->_R Sym (Zepto.N:ZeptoT[0]
<StateT Point m_X7yh>_R <c>_N) ; Sym (Main.N:P[0] <m_X7yh>_R) <c>_N
:: (forall a b c.
(a -> b -> c)
-> ZeptoT (StateT Point m_X7yh) a
-> ZeptoT (StateT Point m_X7yh) b
-> Zepto.S
-> StateT Point m_X7yh (Zepto.Result c) :: *)
~R# (forall a b c.
(a -> b -> c) -> P m_X7yh a -> P m_X7yh b -> P m_X7yh c :: *)))
((Main.$fApplicativeP2 @ m_X7yh $dMonad_X7yj)
`cast` (forall (a :: <*>_N) (b :: <*>_N).
Sym (Main.N:P[0] <m_X7yh>_R) <a>_N
->_R Sym (Main.N:P[0] <m_X7yh>_R) <b>_N
->_R Sym (Zepto.N:ZeptoT[0]
<StateT Point m_X7yh>_R <b>_N) ; Sym (Main.N:P[0] <m_X7yh>_R) <b>_N
:: (forall a b.
ZeptoT (StateT Point m_X7yh) a
-> ZeptoT (StateT Point m_X7yh) b
-> Zepto.S
-> StateT Point m_X7yh (Zepto.Result b) :: *)
~R# (forall a b. P m_X7yh a -> P m_X7yh b -> P m_X7yh b :: *)))
((Main.$fApplicativeP1 @ m_X7yh $dMonad_X7yj)
`cast` (forall (a :: <*>_N) (b :: <*>_N).
Sym (Main.N:P[0] <m_X7yh>_R) <a>_N
->_R Sym (Main.N:P[0] <m_X7yh>_R) <b>_N
->_R Sym (Zepto.N:ZeptoT[0]
<StateT Point m_X7yh>_R <a>_N) ; Sym (Main.N:P[0] <m_X7yh>_R) <a>_N
:: (forall a b.
ZeptoT (StateT Point m_X7yh) a
-> ZeptoT (StateT Point m_X7yh) b
-> Zepto.S
-> StateT Point m_X7yh (Zepto.Result a) :: *)
~R# (forall a b. P m_X7yh a -> P m_X7yh b -> P m_X7yh a :: *)))
-- RHS size: {terms: 7, types: 17, coercions: 0, joins: 0/0}
Main.$fMonadP3
:: forall (m :: * -> *).
Monad m =>
forall a b.
ZeptoT (StateT Point m) a
-> (a -> ZeptoT (StateT Point m) b) -> ZeptoT (StateT Point m) b
[GblId,
Arity=1,
Caf=NoCafRefs,
Str=<L,U(U(U(C(C1(U)),A),A,A,A,A,A),C(C1(U)),A,C(U),C(U))>,
Unf=Unf{Src=InlineStable, TopLvl=True, Value=True, ConLike=True,
WorkFree=True, Expandable=True,
Guidance=ALWAYS_IF(arity=1,unsat_ok=True,boring_ok=False)
Tmpl= \ (@ (m_X7A9 :: * -> *))
($dMonad_X7Ab [Occ=Once] :: Monad m_X7A9)
(@ a_a7y2)
(@ b_a7y3) ->
Zepto.$fMonadZeptoT_$c>>=
@ (StateT Point m_X7A9)
(Control.Monad.Trans.State.Strict.$fMonadStateT
@ m_X7A9 @ Point $dMonad_X7Ab)
@ a_a7y2
@ b_a7y3}]
Main.$fMonadP3
= \ (@ (m_X7A9 :: * -> *))
($dMonad_X7Ab :: Monad m_X7A9)
(@ a_a7y2)
(@ b_a7y3) ->
Zepto.$fMonadZeptoT_$c>>=
@ (StateT Point m_X7A9)
(Control.Monad.Trans.State.Strict.$fMonadStateT
@ m_X7A9 @ Point $dMonad_X7Ab)
@ a_a7y2
@ b_a7y3
-- RHS size: {terms: 7, types: 17, coercions: 0, joins: 0/0}
Main.$fMonadP2
:: forall (m :: * -> *).
Monad m =>
forall a b.
ZeptoT (StateT Point m) a
-> ZeptoT (StateT Point m) b -> ZeptoT (StateT Point m) b
[GblId,
Arity=1,
Caf=NoCafRefs,
Str=<L,U(U(U(C(C1(U)),A),A,A,A,A,A),C(C1(U)),A,C(U),C(U))>,
Unf=Unf{Src=InlineStable, TopLvl=True, Value=True, ConLike=True,
WorkFree=True, Expandable=True,
Guidance=ALWAYS_IF(arity=1,unsat_ok=True,boring_ok=False)
Tmpl= \ (@ (m_X7A3 :: * -> *))
($dMonad_X7A5 [Occ=Once] :: Monad m_X7A3)
(@ a_a7yw)
(@ b_a7yx) ->
Zepto.$fMonadZeptoT_$c>>
@ (StateT Point m_X7A3)
(Control.Monad.Trans.State.Strict.$fMonadStateT
@ m_X7A3 @ Point $dMonad_X7A5)
@ a_a7yw
@ b_a7yx}]
Main.$fMonadP2
= \ (@ (m_X7A3 :: * -> *))
($dMonad_X7A5 :: Monad m_X7A3)
(@ a_a7yw)
(@ b_a7yx) ->
Zepto.$fMonadZeptoT_$c>>
@ (StateT Point m_X7A3)
(Control.Monad.Trans.State.Strict.$fMonadStateT
@ m_X7A3 @ Point $dMonad_X7A5)
@ a_a7yw
@ b_a7yx
-- RHS size: {terms: 6, types: 14, coercions: 0, joins: 0/0}
Main.$fMonadP1
:: forall (m :: * -> *).
Monad m =>
forall a. String -> ZeptoT (StateT Point m) a
[GblId,
Arity=1,
Caf=NoCafRefs,
Str=<L,U(U(U(C(C1(U)),A),A,A,A,A,A),C(C1(U)),A,C(U),C(U))>,
Unf=Unf{Src=InlineStable, TopLvl=True, Value=True, ConLike=True,
WorkFree=True, Expandable=True,
Guidance=ALWAYS_IF(arity=1,unsat_ok=True,boring_ok=False)
Tmpl= \ (@ (m_a7xT :: * -> *))
($dMonad_a7xU [Occ=Once] :: Monad m_a7xT)
(@ a_a7ze) ->
Zepto.$fMonadFailZeptoT_$cfail
@ (StateT Point m_a7xT)
(Control.Monad.Trans.State.Strict.$fMonadStateT
@ m_a7xT @ Point $dMonad_a7xU)
@ a_a7ze}]
Main.$fMonadP1
= \ (@ (m_a7xT :: * -> *))
($dMonad_a7xU :: Monad m_a7xT)
(@ a_a7ze) ->
Zepto.$fMonadFailZeptoT_$cfail
@ (StateT Point m_a7xT)
(Control.Monad.Trans.State.Strict.$fMonadStateT
@ m_a7xT @ Point $dMonad_a7xU)
@ a_a7ze
-- RHS size: {terms: 13, types: 13, coercions: 61, joins: 0/0}
Main.$fMonadP [InlPrag=NOUSERINLINE CONLIKE]
:: forall (m :: * -> *). Monad m => Monad (P m)
[GblId[DFunId],
Arity=1,
Caf=NoCafRefs,
Str=<L,U(U(U(C(C1(U)),A),A,A,A,A,A),C(C1(U)),A,C(U),C(U))>m,
Unf=DFun: \ (@ (m_a4AL :: * -> *)) (v_X5U :: Monad m_a4AL) ->
GHC.Base.C:Monad TYPE: P m_a4AL
Main.$fApplicativeP @ m_a4AL v_X5U
(Main.$fMonadP3 @ m_a4AL v_X5U)
`cast` (forall (a :: <*>_N) (b :: <*>_N).
Sym (Main.N:P[0] <m_a4AL>_R) <a>_N
->_R (<a>_R ->_R Sym (Main.N:P[0] <m_a4AL>_R) <b>_N)
->_R Sym (Main.N:P[0] <m_a4AL>_R) <b>_N
:: (forall a b.
ZeptoT (StateT Point m_a4AL) a
-> (a -> ZeptoT (StateT Point m_a4AL) b)
-> ZeptoT (StateT Point m_a4AL) b :: *)
~R# (forall a b.
P m_a4AL a -> (a -> P m_a4AL b) -> P m_a4AL b :: *))
(Main.$fMonadP2 @ m_a4AL v_X5U)
`cast` (forall (a :: <*>_N) (b :: <*>_N).
Sym (Main.N:P[0] <m_a4AL>_R) <a>_N
->_R Sym (Main.N:P[0] <m_a4AL>_R) <b>_N
->_R Sym (Main.N:P[0] <m_a4AL>_R) <b>_N
:: (forall a b.
ZeptoT (StateT Point m_a4AL) a
-> ZeptoT (StateT Point m_a4AL) b
-> ZeptoT (StateT Point m_a4AL) b :: *)
~R# (forall a b. P m_a4AL a -> P m_a4AL b -> P m_a4AL b :: *))
(Main.$fApplicativeP5 @ m_a4AL v_X5U)
`cast` (forall (a :: <*>_N).
<a>_R ->_R Sym (Main.N:P[0] <m_a4AL>_R) <a>_N
:: (forall a. a -> ZeptoT (StateT Point m_a4AL) a :: *)
~R# (forall a. a -> P m_a4AL a :: *))
(Main.$fMonadP1 @ m_a4AL v_X5U)
`cast` (forall (a :: <*>_N).
<[Char]>_R ->_R Sym (Main.N:P[0] <m_a4AL>_R) <a>_N
:: (forall a. [Char] -> ZeptoT (StateT Point m_a4AL) a :: *)
~R# (forall a. [Char] -> P m_a4AL a :: *))]
Main.$fMonadP
= \ (@ (m_X7AI :: * -> *)) ($dMonad_X7AK :: Monad m_X7AI) ->
GHC.Base.C:Monad
@ (P m_X7AI)
(Main.$fApplicativeP @ m_X7AI $dMonad_X7AK)
((Main.$fMonadP3 @ m_X7AI $dMonad_X7AK)
`cast` (forall (a :: <*>_N) (b :: <*>_N).
Sym (Main.N:P[0] <m_X7AI>_R) <a>_N
->_R (<a>_R ->_R Sym (Main.N:P[0] <m_X7AI>_R) <b>_N)
->_R Sym (Main.N:P[0] <m_X7AI>_R) <b>_N
:: (forall a b.
ZeptoT (StateT Point m_X7AI) a
-> (a -> ZeptoT (StateT Point m_X7AI) b)
-> ZeptoT (StateT Point m_X7AI) b :: *)
~R# (forall a b.
P m_X7AI a -> (a -> P m_X7AI b) -> P m_X7AI b :: *)))
((Main.$fMonadP2 @ m_X7AI $dMonad_X7AK)
`cast` (forall (a :: <*>_N) (b :: <*>_N).
Sym (Main.N:P[0] <m_X7AI>_R) <a>_N
->_R Sym (Main.N:P[0] <m_X7AI>_R) <b>_N
->_R Sym (Main.N:P[0] <m_X7AI>_R) <b>_N
:: (forall a b.
ZeptoT (StateT Point m_X7AI) a
-> ZeptoT (StateT Point m_X7AI) b
-> ZeptoT (StateT Point m_X7AI) b :: *)
~R# (forall a b. P m_X7AI a -> P m_X7AI b -> P m_X7AI b :: *)))
((Main.$fApplicativeP5 @ m_X7AI $dMonad_X7AK)
`cast` (forall (a :: <*>_N).
<a>_R ->_R Sym (Main.N:P[0] <m_X7AI>_R) <a>_N
:: (forall a. a -> ZeptoT (StateT Point m_X7AI) a :: *)
~R# (forall a. a -> P m_X7AI a :: *)))
((Main.$fMonadP1 @ m_X7AI $dMonad_X7AK)
`cast` (forall (a :: <*>_N).
<[Char]>_R ->_R Sym (Main.N:P[0] <m_X7AI>_R) <a>_N
:: (forall a. [Char] -> ZeptoT (StateT Point m_X7AI) a :: *)
~R# (forall a. [Char] -> P m_X7AI a :: *)))
-- RHS size: {terms: 5, types: 8, coercions: 0, joins: 0/0}
Main.$fMonadIOP_$cp1MonadIO
:: forall (m :: * -> *). MonadIO m => Monad (P m)
[GblId,
Arity=1,
Caf=NoCafRefs,
Str=<L,1*U(1*U(U(U(C(C1(U)),A),A,A,A,A,A),C(C1(U)),A,C(U),C(U)),A)>m,
Unf=Unf{Src=InlineStable, TopLvl=True, Value=True, ConLike=True,
WorkFree=True, Expandable=True,
Guidance=ALWAYS_IF(arity=1,unsat_ok=True,boring_ok=False)
Tmpl= \ (@ (m_X7DD :: * -> *))
($dMonadIO_X7DF [Occ=Once] :: MonadIO m_X7DD) ->
Main.$fMonadP
@ m_X7DD
(Control.Monad.IO.Class.$p1MonadIO @ m_X7DD $dMonadIO_X7DF)}]
Main.$fMonadIOP_$cp1MonadIO
= \ (@ (m_X7DD :: * -> *)) ($dMonadIO_X7DF :: MonadIO m_X7DD) ->
Main.$fMonadP
@ m_X7DD
(Control.Monad.IO.Class.$p1MonadIO @ m_X7DD $dMonadIO_X7DF)
-- RHS size: {terms: 1, types: 0, coercions: 0, joins: 0/0}
Main.$fAlternativeP5 :: GHC.Prim.Addr#
[GblId,
Caf=NoCafRefs,
Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
WorkFree=True, Expandable=True, Guidance=IF_ARGS [] 30 0}]
Main.$fAlternativeP5 = "empty"#
-- RHS size: {terms: 2, types: 0, coercions: 0, joins: 0/0}
Main.$fAlternativeP_msg4 :: String
[GblId,
Unf=Unf{Src=<vanilla>, TopLvl=True, Value=False, ConLike=True,
WorkFree=False, Expandable=True, Guidance=IF_ARGS [] 20 0}]
Main.$fAlternativeP_msg4
= GHC.CString.unpackCString# Main.$fAlternativeP5
-- RHS size: {terms: 3, types: 3, coercions: 0, joins: 0/0}
Main.$fAlternativeP4 :: forall a. Zepto.Result a
[GblId,
Str=m1,
Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
WorkFree=True, Expandable=True, Guidance=IF_ARGS [] 10 20}]
Main.$fAlternativeP4
= \ (@ a_a7zE) -> Zepto.Fail @ a_a7zE Main.$fAlternativeP_msg4
-- RHS size: {terms: 6, types: 14, coercions: 0, joins: 0/0}
Main.$fAlternativeP3
:: forall (m :: * -> *).
Monad m =>
forall a.
ZeptoT (StateT Point m) a
-> ZeptoT (StateT Point m) a -> ZeptoT (StateT Point m) a
[GblId,
Arity=1,
Caf=NoCafRefs,
Str=<L,U(U(U(C(C1(U)),A),A,A,A,A,A),C(C1(U)),A,C(U),C(U))>,
Unf=Unf{Src=InlineStable, TopLvl=True, Value=True, ConLike=True,
WorkFree=True, Expandable=True,
Guidance=ALWAYS_IF(arity=1,unsat_ok=True,boring_ok=False)
Tmpl= \ (@ (m_X7Bp :: * -> *))
($dMonad_X7Br [Occ=Once] :: Monad m_X7Bp)
(@ a_a7zS) ->
Zepto.$fAlternativeZeptoT_$cmplus
@ (StateT Point m_X7Bp)
(Control.Monad.Trans.State.Strict.$fMonadStateT
@ m_X7Bp @ Point $dMonad_X7Br)
@ a_a7zS}]
Main.$fAlternativeP3
= \ (@ (m_X7Bp :: * -> *))
($dMonad_X7Br :: Monad m_X7Bp)
(@ a_a7zS) ->
Zepto.$fAlternativeZeptoT_$cmplus
@ (StateT Point m_X7Bp)
(Control.Monad.Trans.State.Strict.$fMonadStateT
@ m_X7Bp @ Point $dMonad_X7Br)
@ a_a7zS
-- RHS size: {terms: 6, types: 14, coercions: 0, joins: 0/0}
Main.$fAlternativeP2
:: forall (m :: * -> *).
Monad m =>
forall a.
ZeptoT (StateT Point m) a
-> Zepto.S -> StateT Point m (Zepto.Result [a])
[GblId,
Arity=1,
Caf=NoCafRefs,
Str=<L,U(U(U(C(C1(U)),A),A,A,A,A,A),C(C1(U)),A,C(U),C(U))>,
Unf=Unf{Src=InlineStable, TopLvl=True, Value=True, ConLike=True,
WorkFree=True, Expandable=True,
Guidance=ALWAYS_IF(arity=1,unsat_ok=True,boring_ok=False)
Tmpl= \ (@ (m_X7Bk :: * -> *))
($dMonad_X7Bm [Occ=Once] :: Monad m_X7Bk)
(@ a_a7Ae) ->
Zepto.$fAlternativeZeptoT3
@ (StateT Point m_X7Bk)
(Control.Monad.Trans.State.Strict.$fMonadStateT
@ m_X7Bk @ Point $dMonad_X7Bm)
@ a_a7Ae}]
Main.$fAlternativeP2
= \ (@ (m_X7Bk :: * -> *))
($dMonad_X7Bm :: Monad m_X7Bk)
(@ a_a7Ae) ->
Zepto.$fAlternativeZeptoT3
@ (StateT Point m_X7Bk)
(Control.Monad.Trans.State.Strict.$fMonadStateT
@ m_X7Bk @ Point $dMonad_X7Bm)
@ a_a7Ae
-- RHS size: {terms: 6, types: 14, coercions: 0, joins: 0/0}
Main.$fAlternativeP1
:: forall (m :: * -> *).
Monad m =>
forall a.
ZeptoT (StateT Point m) a
-> Zepto.S -> StateT Point m (Zepto.Result [a])
[GblId,
Arity=1,
Caf=NoCafRefs,
Str=<L,U(U(U(C(C1(U)),A),A,A,A,A,A),C(C1(U)),A,C(U),C(U))>,
Unf=Unf{Src=InlineStable, TopLvl=True, Value=True, ConLike=True,
WorkFree=True, Expandable=True,
Guidance=ALWAYS_IF(arity=1,unsat_ok=True,boring_ok=False)
Tmpl= \ (@ (m_a7zv :: * -> *))
($dMonad_a7zw [Occ=Once] :: Monad m_a7zv)
(@ a_a7Aw) ->
Zepto.$fAlternativeZeptoT1
@ (StateT Point m_a7zv)
(Control.Monad.Trans.State.Strict.$fMonadStateT
@ m_a7zv @ Point $dMonad_a7zw)
@ a_a7Aw}]
Main.$fAlternativeP1
= \ (@ (m_a7zv :: * -> *))
($dMonad_a7zw :: Monad m_a7zv)
(@ a_a7Aw) ->
Zepto.$fAlternativeZeptoT1
@ (StateT Point m_a7zv)
(Control.Monad.Trans.State.Strict.$fMonadStateT
@ m_a7zv @ Point $dMonad_a7zw)
@ a_a7Aw
-- RHS size: {terms: 19, types: 25, coercions: 82, joins: 0/0}
Main.$fAlternativeP [InlPrag=NOUSERINLINE CONLIKE]
:: forall (m :: * -> *). Monad m => Alternative (P m)
[GblId[DFunId],
Arity=1,
Str=<L,U(U(U(C(C1(U)),A),A,A,A,A,A),C(C1(U)),A,C(U),C(U))>m,
Unf=DFun: \ (@ (m_a4AL :: * -> *)) (v_X61 :: Monad m_a4AL) ->
GHC.Base.C:Alternative TYPE: P m_a4AL
Main.$fApplicativeP @ m_a4AL v_X61
(\ (@ a_X7FR) _ [Occ=Dead] (eta_X6g [Occ=Once] :: Point) ->
return
@ m_a4AL
v_X61
@ (Zepto.Result a_X7FR, Point)
(Main.$fAlternativeP4 @ a_X7FR, eta_X6g))
`cast` (forall (a :: <*>_N).
(<Zepto.S>_R
->_R Sym (Control.Monad.Trans.State.Strict.N:StateT[0]
<Point>_N
<m_a4AL>_R
<Zepto.Result a>_N)) ; (Sym (Zepto.N:ZeptoT[0]
<StateT
Point
m_a4AL>_R
<a>_N) ; Sym (Main.N:P[0]
<m_a4AL>_R) <a>_N)
:: (forall a.
Zepto.S -> Point -> m_a4AL (Zepto.Result a, Point) :: *)
~R# (forall a. P m_a4AL a :: *))
(Main.$fAlternativeP3 @ m_a4AL v_X61)
`cast` (forall (a :: <*>_N).
Sym (Main.N:P[0] <m_a4AL>_R) <a>_N
->_R Sym (Main.N:P[0] <m_a4AL>_R) <a>_N
->_R Sym (Main.N:P[0] <m_a4AL>_R) <a>_N
:: (forall a.
ZeptoT (StateT Point m_a4AL) a
-> ZeptoT (StateT Point m_a4AL) a
-> ZeptoT (StateT Point m_a4AL) a :: *)
~R# (forall a.
P m_a4AL a -> P m_a4AL a -> P m_a4AL a :: *))
(Main.$fAlternativeP2 @ m_a4AL v_X61)
`cast` (forall (a :: <*>_N).
Sym (Main.N:P[0] <m_a4AL>_R) <a>_N
->_R Sym (Zepto.N:ZeptoT[0]
<StateT Point m_a4AL>_R
<[a]>_N) ; Sym (Main.N:P[0] <m_a4AL>_R) <[a]>_N
:: (forall a.
ZeptoT (StateT Point m_a4AL) a
-> Zepto.S -> StateT Point m_a4AL (Zepto.Result [a]) :: *)
~R# (forall a. P m_a4AL a -> P m_a4AL [a] :: *))
(Main.$fAlternativeP1 @ m_a4AL v_X61)
`cast` (forall (a :: <*>_N).
Sym (Main.N:P[0] <m_a4AL>_R) <a>_N
->_R Sym (Zepto.N:ZeptoT[0]
<StateT Point m_a4AL>_R
<[a]>_N) ; Sym (Main.N:P[0] <m_a4AL>_R) <[a]>_N
:: (forall a.
ZeptoT (StateT Point m_a4AL) a
-> Zepto.S -> StateT Point m_a4AL (Zepto.Result [a]) :: *)
~R# (forall a. P m_a4AL a -> P m_a4AL [a] :: *))]
Main.$fAlternativeP
= \ (@ (m_X7Cn :: * -> *)) ($dMonad_X7Cp :: Monad m_X7Cn) ->
GHC.Base.C:Alternative
@ (P m_X7Cn)
(Main.$fApplicativeP @ m_X7Cn $dMonad_X7Cp)
((\ (@ a_X7FR) _ [Occ=Dead] (eta_X64 :: Point) ->
return
@ m_X7Cn
$dMonad_X7Cp
@ (Zepto.Result a_X7FR, Point)
(Main.$fAlternativeP4 @ a_X7FR, eta_X64))
`cast` (forall (a :: <*>_N).
(<Zepto.S>_R
->_R Sym (Control.Monad.Trans.State.Strict.N:StateT[0]
<Point>_N <m_X7Cn>_R <Zepto.Result a>_N)) ; (Sym (Zepto.N:ZeptoT[0]
<StateT
Point
m_X7Cn>_R
<a>_N) ; Sym (Main.N:P[0]
<m_X7Cn>_R) <a>_N)
:: (forall a.
Zepto.S -> Point -> m_X7Cn (Zepto.Result a, Point) :: *)
~R# (forall a. P m_X7Cn a :: *)))
((Main.$fAlternativeP3 @ m_X7Cn $dMonad_X7Cp)
`cast` (forall (a :: <*>_N).
Sym (Main.N:P[0] <m_X7Cn>_R) <a>_N
->_R Sym (Main.N:P[0] <m_X7Cn>_R) <a>_N
->_R Sym (Main.N:P[0] <m_X7Cn>_R) <a>_N
:: (forall a.
ZeptoT (StateT Point m_X7Cn) a
-> ZeptoT (StateT Point m_X7Cn) a
-> ZeptoT (StateT Point m_X7Cn) a :: *)
~R# (forall a. P m_X7Cn a -> P m_X7Cn a -> P m_X7Cn a :: *)))
((Main.$fAlternativeP2 @ m_X7Cn $dMonad_X7Cp)
`cast` (forall (a :: <*>_N).
Sym (Main.N:P[0] <m_X7Cn>_R) <a>_N
->_R Sym (Zepto.N:ZeptoT[0]
<StateT Point m_X7Cn>_R <[a]>_N) ; Sym (Main.N:P[0]
<m_X7Cn>_R) <[a]>_N
:: (forall a.
ZeptoT (StateT Point m_X7Cn) a
-> Zepto.S -> StateT Point m_X7Cn (Zepto.Result [a]) :: *)
~R# (forall a. P m_X7Cn a -> P m_X7Cn [a] :: *)))
((Main.$fAlternativeP1 @ m_X7Cn $dMonad_X7Cp)
`cast` (forall (a :: <*>_N).
Sym (Main.N:P[0] <m_X7Cn>_R) <a>_N
->_R Sym (Zepto.N:ZeptoT[0]
<StateT Point m_X7Cn>_R <[a]>_N) ; Sym (Main.N:P[0]
<m_X7Cn>_R) <[a]>_N
:: (forall a.
ZeptoT (StateT Point m_X7Cn) a
-> Zepto.S -> StateT Point m_X7Cn (Zepto.Result [a]) :: *)
~R# (forall a. P m_X7Cn a -> P m_X7Cn [a] :: *)))
-- RHS size: {terms: 6, types: 14, coercions: 0, joins: 0/0}
Main.$fMonadIOP1
:: forall (m :: * -> *).
MonadIO m =>
forall a. IO a -> ZeptoT (StateT Point m) a
[GblId,
Arity=1,
Caf=NoCafRefs,
Str=<L,U(U(U(U(C(C1(U)),A),A,A,A,A,A),C(C1(U)),A,C(U),C(U)),C(U))>,
Unf=Unf{Src=InlineStable, TopLvl=True, Value=True, ConLike=True,
WorkFree=True, Expandable=True,
Guidance=ALWAYS_IF(arity=1,unsat_ok=True,boring_ok=False)
Tmpl= \ (@ (m_a7AN :: * -> *))
($dMonadIO_a7AO [Occ=Once] :: MonadIO m_a7AN)
(@ a_a7AW) ->
Zepto.$fMonadIOZeptoT_$cliftIO
@ (StateT Point m_a7AN)
(Control.Monad.Trans.State.Strict.$fMonadIOStateT
@ m_a7AN @ Point $dMonadIO_a7AO)
@ a_a7AW}]
Main.$fMonadIOP1
= \ (@ (m_a7AN :: * -> *))
($dMonadIO_a7AO :: MonadIO m_a7AN)
(@ a_a7AW) ->
Zepto.$fMonadIOZeptoT_$cliftIO
@ (StateT Point m_a7AN)
(Control.Monad.Trans.State.Strict.$fMonadIOStateT
@ m_a7AN @ Point $dMonadIO_a7AO)
@ a_a7AW
-- RHS size: {terms: 7, types: 10, coercions: 10, joins: 0/0}
Main.$fMonadIOP [InlPrag=NOUSERINLINE CONLIKE]
:: forall (m :: * -> *). MonadIO m => MonadIO (P m)
[GblId[DFunId],
Arity=1,
Caf=NoCafRefs,
Str=<L,U(U(U(U(C(C1(U)),A),A,A,A,A,A),C(C1(U)),A,C(U),C(U)),C(U))>m,
Unf=DFun: \ (@ (m_a4AL :: * -> *)) (v_X63 :: MonadIO m_a4AL) ->
Control.Monad.IO.Class.C:MonadIO TYPE: P m_a4AL
Main.$fMonadIOP_$cp1MonadIO @ m_a4AL v_X63
(Main.$fMonadIOP1 @ m_a4AL v_X63)
`cast` (forall (a :: <*>_N).
<IO a>_R ->_R Sym (Main.N:P[0] <m_a4AL>_R) <a>_N
:: (forall a.
IO a -> ZeptoT (StateT Point m_a4AL) a :: *)
~R# (forall a. IO a -> P m_a4AL a :: *))]
Main.$fMonadIOP
= \ (@ (m_X7DE :: * -> *)) ($dMonadIO_X7DG :: MonadIO m_X7DE) ->
Control.Monad.IO.Class.C:MonadIO
@ (P m_X7DE)
(Main.$fMonadIOP_$cp1MonadIO @ m_X7DE $dMonadIO_X7DG)
((Main.$fMonadIOP1 @ m_X7DE $dMonadIO_X7DG)
`cast` (forall (a :: <*>_N).
<IO a>_R ->_R Sym (Main.N:P[0] <m_X7DE>_R) <a>_N
:: (forall a. IO a -> ZeptoT (StateT Point m_X7DE) a :: *)
~R# (forall a. IO a -> P m_X7DE a :: *)))
-- RHS size: {terms: 20, types: 102, coercions: 142, joins: 0/0}
Main.$fGenericToken1
:: forall x.
Token
-> M1
C
('MetaCons "Token" 'PrefixI 'True)
(M1
S
('MetaSel
('Just "byteString") 'SourceUnpack 'SourceStrict 'DecidedUnpack)
(K1 R ByteString)
:*: (M1
S
('MetaSel
('Just "start") 'SourceUnpack 'SourceStrict 'DecidedUnpack)
(K1 R Point)
:*: M1
S
('MetaSel ('Just "end") 'SourceUnpack 'SourceStrict 'DecidedUnpack)
(K1 R Point)))
x
[GblId,
Arity=1,
Caf=NoCafRefs,
Str=<S,1*U(U,U,U,U,U,U,U,U,U,U)>m,
Unf=Unf{Src=InlineStable, TopLvl=True, Value=True, ConLike=True,
WorkFree=True, Expandable=True,
Guidance=ALWAYS_IF(arity=1,unsat_ok=True,boring_ok=False)
Tmpl= \ (@ x_a7C5) (x1_a6TH [Occ=Once!] :: Token) ->
case x1_a6TH of
{ Token dt_d7Wz [Occ=Once] dt1_d7WA [Occ=Once] dt2_d7WB [Occ=Once]
dt3_d7WC [Occ=Once] dt4_d7WD [Occ=Once] dt5_d7WE [Occ=Once]
dt6_d7WF [Occ=Once] dt7_d7WG [Occ=Once] dt8_d7WH [Occ=Once]
dt9_d7WI [Occ=Once] ->
(GHC.Generics.:*:
@ *
@ (M1
S
('MetaSel
('Just "byteString") 'SourceUnpack 'SourceStrict 'DecidedUnpack)
(K1 R ByteString))
@ (M1
S
('MetaSel
('Just "start") 'SourceUnpack 'SourceStrict 'DecidedUnpack)
(K1 R Point)
:*: M1
S
('MetaSel ('Just "end") 'SourceUnpack 'SourceStrict 'DecidedUnpack)
(K1 R Point))
@ x_a7C5
((Data.ByteString.Internal.PS dt_d7Wz dt1_d7WA dt2_d7WB dt3_d7WC)
`cast` (Sym (GHC.Generics.N:K1[0]
<*>_N
<R>_P
<ByteString>_R
<x_a7C5>_P) ; Sym (GHC.Generics.N:M1[0]
<*>_N
<S>_P
<'MetaSel
('Just "byteString")
'SourceUnpack
'SourceStrict
'DecidedUnpack>_P
<K1 R ByteString>_R) <x_a7C5>_N
:: (ByteString :: *)
~R# (M1
S
('MetaSel
('Just "byteString")
'SourceUnpack
'SourceStrict
'DecidedUnpack)
(K1 R ByteString)
x_a7C5 :: *)))
(GHC.Generics.:*:
@ *
@ (M1
S
('MetaSel
('Just "start") 'SourceUnpack 'SourceStrict 'DecidedUnpack)
(K1 R Point))
@ (M1
S
('MetaSel ('Just "end") 'SourceUnpack 'SourceStrict 'DecidedUnpack)
(K1 R Point))
@ x_a7C5
((Main.Point dt4_d7WD dt5_d7WE dt6_d7WF)
`cast` (Sym (GHC.Generics.N:K1[0]
<*>_N
<R>_P
<Point>_R
<x_a7C5>_P) ; Sym (GHC.Generics.N:M1[0]
<*>_N
<S>_P
<'MetaSel
('Just "start")
'SourceUnpack
'SourceStrict
'DecidedUnpack>_P
<K1 R Point>_R) <x_a7C5>_N
:: (Point :: *)
~R# (M1
S
('MetaSel
('Just "start")
'SourceUnpack
'SourceStrict
'DecidedUnpack)
(K1 R Point)
x_a7C5 :: *)))
((Main.Point dt7_d7WG dt8_d7WH dt9_d7WI)
`cast` (Sym (GHC.Generics.N:K1[0]
<*>_N
<R>_P
<Point>_R
<x_a7C5>_P) ; Sym (GHC.Generics.N:M1[0]
<*>_N
<S>_P
<'MetaSel
('Just "end")
'SourceUnpack
'SourceStrict
'DecidedUnpack>_P
<K1 R Point>_R) <x_a7C5>_N
:: (Point :: *)
~R# (M1
S
('MetaSel
('Just "end")
'SourceUnpack
'SourceStrict
'DecidedUnpack)
(K1 R Point)
x_a7C5 :: *)))))
`cast` (Sym (GHC.Generics.N:M1[0]
<*>_N
<C>_P
<'MetaCons "Token" 'PrefixI 'True>_P
<M1
S
('MetaSel
('Just "byteString")
'SourceUnpack
'SourceStrict
'DecidedUnpack)
(K1 R ByteString)
:*: (M1
S
('MetaSel
('Just "start")
'SourceUnpack
'SourceStrict
'DecidedUnpack)
(K1 R Point)
:*: M1
S
('MetaSel
('Just "end")
'SourceUnpack
'SourceStrict
'DecidedUnpack)
(K1 R Point))>_R) <x_a7C5>_N
:: ((:*:)
(M1
S
('MetaSel
('Just "byteString")
'SourceUnpack
'SourceStrict
'DecidedUnpack)
(K1 R ByteString))
(M1
S
('MetaSel
('Just "start") 'SourceUnpack 'SourceStrict 'DecidedUnpack)
(K1 R Point)
:*: M1
S
('MetaSel
('Just "end") 'SourceUnpack 'SourceStrict 'DecidedUnpack)
(K1 R Point))
x_a7C5 :: *)
~R# (M1
C
('MetaCons "Token" 'PrefixI 'True)
(M1
S
('MetaSel
('Just "byteString")
'SourceUnpack
'SourceStrict
'DecidedUnpack)
(K1 R ByteString)
:*: (M1
S
('MetaSel
('Just "start")
'SourceUnpack
'SourceStrict
'DecidedUnpack)
(K1 R Point)
:*: M1
S
('MetaSel
('Just "end")
'SourceUnpack
'SourceStrict
'DecidedUnpack)
(K1 R Point)))
x_a7C5 :: *))
}}]
Main.$fGenericToken1
= \ (@ x_a7C5) (x1_a6TH :: Token) ->
case x1_a6TH of
{ Token dt_d7Wz dt1_d7WA dt2_d7WB dt3_d7WC dt4_d7WD dt5_d7WE
dt6_d7WF dt7_d7WG dt8_d7WH dt9_d7WI ->
(GHC.Generics.:*:
@ *
@ (M1
S
('MetaSel
('Just "byteString") 'SourceUnpack 'SourceStrict 'DecidedUnpack)
(K1 R ByteString))
@ (M1
S
('MetaSel
('Just "start") 'SourceUnpack 'SourceStrict 'DecidedUnpack)
(K1 R Point)
:*: M1
S
('MetaSel ('Just "end") 'SourceUnpack 'SourceStrict 'DecidedUnpack)
(K1 R Point))
@ x_a7C5
((Data.ByteString.Internal.PS dt_d7Wz dt1_d7WA dt2_d7WB dt3_d7WC)
`cast` (Sym (GHC.Generics.N:K1[0]
<*>_N <R>_P <ByteString>_R <x_a7C5>_P) ; Sym (GHC.Generics.N:M1[0]
<*>_N
<S>_P
<'MetaSel
('Just "byteString")
'SourceUnpack
'SourceStrict
'DecidedUnpack>_P
<K1
R
ByteString>_R) <x_a7C5>_N
:: (ByteString :: *)
~R# (M1
S
('MetaSel
('Just "byteString") 'SourceUnpack 'SourceStrict 'DecidedUnpack)
(K1 R ByteString)
x_a7C5 :: *)))
(GHC.Generics.:*:
@ *
@ (M1
S
('MetaSel
('Just "start") 'SourceUnpack 'SourceStrict 'DecidedUnpack)
(K1 R Point))
@ (M1
S
('MetaSel ('Just "end") 'SourceUnpack 'SourceStrict 'DecidedUnpack)
(K1 R Point))
@ x_a7C5
((Main.Point dt4_d7WD dt5_d7WE dt6_d7WF)
`cast` (Sym (GHC.Generics.N:K1[0]
<*>_N <R>_P <Point>_R <x_a7C5>_P) ; Sym (GHC.Generics.N:M1[0]
<*>_N
<S>_P
<'MetaSel
('Just "start")
'SourceUnpack
'SourceStrict
'DecidedUnpack>_P
<K1
R Point>_R) <x_a7C5>_N
:: (Point :: *)
~R# (M1
S
('MetaSel
('Just "start") 'SourceUnpack 'SourceStrict 'DecidedUnpack)
(K1 R Point)
x_a7C5 :: *)))
((Main.Point dt7_d7WG dt8_d7WH dt9_d7WI)
`cast` (Sym (GHC.Generics.N:K1[0]
<*>_N <R>_P <Point>_R <x_a7C5>_P) ; Sym (GHC.Generics.N:M1[0]
<*>_N
<S>_P
<'MetaSel
('Just "end")
'SourceUnpack
'SourceStrict
'DecidedUnpack>_P
<K1
R Point>_R) <x_a7C5>_N
:: (Point :: *)
~R# (M1
S
('MetaSel ('Just "end") 'SourceUnpack 'SourceStrict 'DecidedUnpack)
(K1 R Point)
x_a7C5 :: *)))))
`cast` (Sym (GHC.Generics.N:M1[0]
<*>_N
<C>_P
<'MetaCons "Token" 'PrefixI 'True>_P
<M1
S
('MetaSel
('Just "byteString") 'SourceUnpack 'SourceStrict 'DecidedUnpack)
(K1 R ByteString)
:*: (M1
S
('MetaSel
('Just "start") 'SourceUnpack 'SourceStrict 'DecidedUnpack)
(K1 R Point)
:*: M1
S
('MetaSel
('Just "end") 'SourceUnpack 'SourceStrict 'DecidedUnpack)
(K1 R Point))>_R) <x_a7C5>_N
:: ((:*:)
(M1
S
('MetaSel
('Just "byteString") 'SourceUnpack 'SourceStrict 'DecidedUnpack)
(K1 R ByteString))
(M1
S
('MetaSel
('Just "start") 'SourceUnpack 'SourceStrict 'DecidedUnpack)
(K1 R Point)
:*: M1
S
('MetaSel ('Just "end") 'SourceUnpack 'SourceStrict 'DecidedUnpack)
(K1 R Point))
x_a7C5 :: *)
~R# (M1
C
('MetaCons "Token" 'PrefixI 'True)
(M1
S
('MetaSel
('Just "byteString") 'SourceUnpack 'SourceStrict 'DecidedUnpack)
(K1 R ByteString)
:*: (M1
S
('MetaSel
('Just "start") 'SourceUnpack 'SourceStrict 'DecidedUnpack)
(K1 R Point)
:*: M1
S
('MetaSel
('Just "end") 'SourceUnpack 'SourceStrict 'DecidedUnpack)
(K1 R Point)))
x_a7C5 :: *))
}
-- RHS size: {terms: 12, types: 182, coercions: 210, joins: 0/0}
Main.$fGenericToken_$cto :: forall x. Rep Token x -> Token
[GblId,
Arity=1,
Caf=NoCafRefs,
Str=<S(SS(SS)),1*U(U,1*U(U,U))>m,
Unf=Unf{Src=InlineStable, TopLvl=True, Value=True, ConLike=True,
WorkFree=True, Expandable=True,
Guidance=ALWAYS_IF(arity=1,unsat_ok=True,boring_ok=False)
Tmpl= \ (@ x_a7CX) (ds_d7QQ [Occ=Once] :: Rep Token x_a7CX) ->
case ds_d7QQ
`cast` ((Sub (Main.Rep_Token[0]) ; (GHC.Generics.N:M1[0]
<*>_N
<D>_P
<'MetaData
"Token" "Main" "main" 'False>_P
<M1
C
('MetaCons "Token" 'PrefixI 'True)
(M1
S
('MetaSel
('Just "byteString")
'SourceUnpack
'SourceStrict
'DecidedUnpack)
(K1 R ByteString)
:*: (M1
S
('MetaSel
('Just "start")
'SourceUnpack
'SourceStrict
'DecidedUnpack)
(K1 R Point)
:*: M1
S
('MetaSel
('Just "end")
'SourceUnpack
'SourceStrict
'DecidedUnpack)
(K1
R
Point)))>_R ; GHC.Generics.N:M1[0]
<*>_N
<C>_P
<'MetaCons
"Token"
'PrefixI
'True>_P
<M1
S
('MetaSel
('Just
"byteString")
'SourceUnpack
'SourceStrict
'DecidedUnpack)
(K1
R
ByteString)
:*: (M1
S
('MetaSel
('Just
"start")
'SourceUnpack
'SourceStrict
'DecidedUnpack)
(K1
R
Point)
:*: M1
S
('MetaSel
('Just
"end")
'SourceUnpack
'SourceStrict
'DecidedUnpack)
(K1
R
Point))>_R)) <x_a7CX>_N
:: (Rep Token x_a7CX :: *)
~R# ((:*:)
(M1
S
('MetaSel
('Just "byteString")
'SourceUnpack
'SourceStrict
'DecidedUnpack)
(K1 R ByteString))
(M1
S
('MetaSel
('Just "start")
'SourceUnpack
'SourceStrict
'DecidedUnpack)
(K1 R Point)
:*: M1
S
('MetaSel
('Just "end")
'SourceUnpack
'SourceStrict
'DecidedUnpack)
(K1 R Point))
x_a7CX :: *))
of
{ :*: ds1_d7QT [Occ=Once] ds2_d7QU [Occ=Once!] ->
case ds2_d7QU of { :*: ds3_d7QW [Occ=Once] ds4_d7QX [Occ=Once] ->
Main.$WToken
(ds1_d7QT
`cast` (GHC.Generics.N:M1[0]
<*>_N
<S>_P
<'MetaSel
('Just "byteString")
'SourceUnpack
'SourceStrict
'DecidedUnpack>_P
<K1 R ByteString>_R <x_a7CX>_N ; GHC.Generics.N:K1[0]
<*>_N
<R>_P
<ByteString>_R
<x_a7CX>_P
:: (M1
S
('MetaSel
('Just "byteString")
'SourceUnpack
'SourceStrict
'DecidedUnpack)
(K1 R ByteString)
x_a7CX :: *)
~R# (ByteString :: *)))
(ds3_d7QW
`cast` (GHC.Generics.N:M1[0]
<*>_N
<S>_P
<'MetaSel
('Just "start") 'SourceUnpack 'SourceStrict 'DecidedUnpack>_P
<K1 R Point>_R <x_a7CX>_N ; GHC.Generics.N:K1[0]
<*>_N <R>_P <Point>_R <x_a7CX>_P
:: (M1
S
('MetaSel
('Just "start") 'SourceUnpack 'SourceStrict 'DecidedUnpack)
(K1 R Point)
x_a7CX :: *)
~R# (Point :: *)))
(ds4_d7QX
`cast` (GHC.Generics.N:M1[0]
<*>_N
<S>_P
<'MetaSel
('Just "end") 'SourceUnpack 'SourceStrict 'DecidedUnpack>_P
<K1 R Point>_R <x_a7CX>_N ; GHC.Generics.N:K1[0]
<*>_N <R>_P <Point>_R <x_a7CX>_P
:: (M1
S
('MetaSel
('Just "end") 'SourceUnpack 'SourceStrict 'DecidedUnpack)
(K1 R Point)
x_a7CX :: *)
~R# (Point :: *)))
}
}}]
Main.$fGenericToken_$cto
= \ (@ x_a7CX) (ds_d7QQ :: Rep Token x_a7CX) ->
case ds_d7QQ
`cast` ((Sub (Main.Rep_Token[0]) ; (GHC.Generics.N:M1[0]
<*>_N
<D>_P
<'MetaData "Token" "Main" "main" 'False>_P
<M1
C
('MetaCons "Token" 'PrefixI 'True)
(M1
S
('MetaSel
('Just "byteString")
'SourceUnpack
'SourceStrict
'DecidedUnpack)
(K1 R ByteString)
:*: (M1
S
('MetaSel
('Just "start")
'SourceUnpack
'SourceStrict
'DecidedUnpack)
(K1 R Point)
:*: M1
S
('MetaSel
('Just "end")
'SourceUnpack
'SourceStrict
'DecidedUnpack)
(K1
R
Point)))>_R ; GHC.Generics.N:M1[0]
<*>_N
<C>_P
<'MetaCons
"Token"
'PrefixI
'True>_P
<M1
S
('MetaSel
('Just
"byteString")
'SourceUnpack
'SourceStrict
'DecidedUnpack)
(K1
R
ByteString)
:*: (M1
S
('MetaSel
('Just
"start")
'SourceUnpack
'SourceStrict
'DecidedUnpack)
(K1
R
Point)
:*: M1
S
('MetaSel
('Just
"end")
'SourceUnpack
'SourceStrict
'DecidedUnpack)
(K1
R
Point))>_R)) <x_a7CX>_N
:: (Rep Token x_a7CX :: *)
~R# ((:*:)
(M1
S
('MetaSel
('Just "byteString") 'SourceUnpack 'SourceStrict 'DecidedUnpack)
(K1 R ByteString))
(M1
S
('MetaSel
('Just "start") 'SourceUnpack 'SourceStrict 'DecidedUnpack)
(K1 R Point)
:*: M1
S
('MetaSel
('Just "end") 'SourceUnpack 'SourceStrict 'DecidedUnpack)
(K1 R Point))
x_a7CX :: *))
of
{ :*: ds1_d7QT ds2_d7QU ->
case ds2_d7QU of { :*: ds3_d7QW ds4_d7QX ->
Main.$WToken
(ds1_d7QT
`cast` (GHC.Generics.N:M1[0]
<*>_N
<S>_P
<'MetaSel
('Just "byteString") 'SourceUnpack 'SourceStrict 'DecidedUnpack>_P
<K1 R ByteString>_R <x_a7CX>_N ; GHC.Generics.N:K1[0]
<*>_N <R>_P <ByteString>_R <x_a7CX>_P
:: (M1
S
('MetaSel
('Just "byteString") 'SourceUnpack 'SourceStrict 'DecidedUnpack)
(K1 R ByteString)
x_a7CX :: *)
~R# (ByteString :: *)))
(ds3_d7QW
`cast` (GHC.Generics.N:M1[0]
<*>_N
<S>_P
<'MetaSel
('Just "start") 'SourceUnpack 'SourceStrict 'DecidedUnpack>_P
<K1 R Point>_R <x_a7CX>_N ; GHC.Generics.N:K1[0]
<*>_N <R>_P <Point>_R <x_a7CX>_P
:: (M1
S
('MetaSel
('Just "start") 'SourceUnpack 'SourceStrict 'DecidedUnpack)
(K1 R Point)
x_a7CX :: *)
~R# (Point :: *)))
(ds4_d7QX
`cast` (GHC.Generics.N:M1[0]
<*>_N
<S>_P
<'MetaSel
('Just "end") 'SourceUnpack 'SourceStrict 'DecidedUnpack>_P
<K1 R Point>_R <x_a7CX>_N ; GHC.Generics.N:K1[0]
<*>_N <R>_P <Point>_R <x_a7CX>_P
:: (M1
S
('MetaSel ('Just "end") 'SourceUnpack 'SourceStrict 'DecidedUnpack)
(K1 R Point)
x_a7CX :: *)
~R# (Point :: *)))
}
}
-- RHS size: {terms: 3, types: 1, coercions: 81, joins: 0/0}
Main.$fGenericToken [InlPrag=NOUSERINLINE CONLIKE] :: Generic Token
[GblId[DFunId],
Caf=NoCafRefs,
Str=m,
Unf=DFun: \ ->
GHC.Generics.C:Generic TYPE: Token
Main.$fGenericToken1
`cast` (forall (x :: <*>_N).
<Token>_R
->_R (Sym (GHC.Generics.N:M1[0]
<*>_N
<D>_P
<'MetaData "Token" "Main" "main" 'False>_P
<M1
C
('MetaCons "Token" 'PrefixI 'True)
(M1
S
('MetaSel
('Just "byteString")
'SourceUnpack
'SourceStrict
'DecidedUnpack)
(K1 R ByteString)
:*: (M1
S
('MetaSel
('Just "start")
'SourceUnpack
'SourceStrict
'DecidedUnpack)
(K1 R Point)
:*: M1
S
('MetaSel
('Just "end")
'SourceUnpack
'SourceStrict
'DecidedUnpack)
(K1
R
Point)))>_R) ; Sub (Sym (Main.Rep_Token[0]))) <x>_N
:: (forall x.
Token
-> M1
C
('MetaCons "Token" 'PrefixI 'True)
(M1
S
('MetaSel
('Just "byteString")
'SourceUnpack
'SourceStrict
'DecidedUnpack)
(K1 R ByteString)
:*: (M1
S
('MetaSel
('Just "start")
'SourceUnpack
'SourceStrict
'DecidedUnpack)
(K1 R Point)
:*: M1
S
('MetaSel
('Just "end")
'SourceUnpack
'SourceStrict
'DecidedUnpack)
(K1 R Point)))
x :: *)
~R# (forall x. Token -> Rep Token x :: *))
Main.$fGenericToken_$cto]
Main.$fGenericToken
= GHC.Generics.C:Generic
@ Token
(Main.$fGenericToken1
`cast` (forall (x :: <*>_N).
<Token>_R
->_R (Sym (GHC.Generics.N:M1[0]
<*>_N
<D>_P
<'MetaData "Token" "Main" "main" 'False>_P
<M1
C
('MetaCons "Token" 'PrefixI 'True)
(M1
S
('MetaSel
('Just "byteString")
'SourceUnpack
'SourceStrict
'DecidedUnpack)
(K1 R ByteString)
:*: (M1
S
('MetaSel
('Just "start")
'SourceUnpack
'SourceStrict
'DecidedUnpack)
(K1 R Point)
:*: M1
S
('MetaSel
('Just "end")
'SourceUnpack
'SourceStrict
'DecidedUnpack)
(K1
R
Point)))>_R) ; Sub (Sym (Main.Rep_Token[0]))) <x>_N
:: (forall x.
Token
-> M1
C
('MetaCons "Token" 'PrefixI 'True)
(M1
S
('MetaSel
('Just "byteString") 'SourceUnpack 'SourceStrict 'DecidedUnpack)
(K1 R ByteString)
:*: (M1
S
('MetaSel
('Just "start") 'SourceUnpack 'SourceStrict 'DecidedUnpack)
(K1 R Point)
:*: M1
S
('MetaSel
('Just "end") 'SourceUnpack 'SourceStrict 'DecidedUnpack)
(K1 R Point)))
x :: *)
~R# (forall x. Token -> Rep Token x :: *)))
Main.$fGenericToken_$cto
-- RHS size: {terms: 28, types: 46, coercions: 0, joins: 0/0}
$clift_rcC8
:: forall (m :: * -> *) a.
Monad m =>
m a -> Zepto.S -> Point -> m (Zepto.Result a, Point)
[GblId,
Arity=4,
Caf=NoCafRefs,
Str=<S(S(S(C(C(S))L)LLLLL)LLLL),U(1*U(1*U(1*C1(C1(U)),A),A,A,A,A,A),1*C1(C1(U)),A,C(U),A)><L,U><L,U><L,U>]
$clift_rcC8
= \ (@ (m_a7E8 :: * -> *))
(@ a_a7E9)
($dMonad_a7Eb :: Monad m_a7E8)
(m1_a4D6 :: m_a7E8 a_a7E9)
(eta_X6b :: Zepto.S)
(eta1_Xcl :: Point) ->
fmap
@ m_a7E8
(GHC.Base.$p1Applicative
@ m_a7E8 (GHC.Base.$p1Monad @ m_a7E8 $dMonad_a7Eb))
@ (a_a7E9, Point)
@ (Zepto.Result a_a7E9, Point)
(\ (ds_a80U :: (a_a7E9, Point)) ->
case ds_a80U of { (a1_a80X, s'_a80Y) ->
(Zepto.$WOK @ a_a7E9 a1_a80X eta_X6b, s'_a80Y)
})
(>>=
@ m_a7E8
$dMonad_a7Eb
@ a_a7E9
@ (a_a7E9, Point)
m1_a4D6
(\ (a1_a80G :: a_a7E9) ->
return
@ m_a7E8 $dMonad_a7Eb @ (a_a7E9, Point) (a1_a80G, eta1_Xcl)))
-- RHS size: {terms: 1, types: 0, coercions: 34, joins: 0/0}
Main.$fMonadTransP_$clift [InlPrag=INLINE (sat-args=1)]
:: forall (m :: * -> *) a. Monad m => m a -> P m a
[GblId,
Arity=4,
Caf=NoCafRefs,
Str=<S(S(S(C(C(S))L)LLLLL)LLLL),U(1*U(1*U(1*C1(C1(U)),A),A,A,A,A,A),1*C1(C1(U)),A,C(U),A)><L,U><L,U><L,U>,
Unf=Unf{Src=InlineStable, TopLvl=True, Value=True, ConLike=True,
WorkFree=True, Expandable=True,
Guidance=ALWAYS_IF(arity=1,unsat_ok=False,boring_ok=False)
Tmpl= \ (@ (m_X7Ga :: * -> *))
(@ a_X7Gc)
($dMonad_X7Gf :: Monad m_X7Ga)
(m1_X4Fb [Occ=OnceL] :: m_X7Ga a_X7Gc) ->
let {
$dFunctor_s815 [Occ=OnceL] :: Applicative m_X7Ga
[LclId]
$dFunctor_s815 = GHC.Base.$p1Monad @ m_X7Ga $dMonad_X7Gf } in
let {
$dFunctor1_s816 [Occ=OnceL] :: Functor m_X7Ga
[LclId]
$dFunctor1_s816
= GHC.Base.$p1Applicative @ m_X7Ga $dFunctor_s815 } in
(\ (s_i7ZK [Occ=OnceL] :: Zepto.S)
(s1_a80T [Occ=OnceL] :: Point) ->
fmap
@ m_X7Ga
$dFunctor1_s816
@ (a_X7Gc, Point)
@ (Zepto.Result a_X7Gc, Point)
(\ (ds_a80U [Occ=Once!] :: (a_X7Gc, Point)) ->
case ds_a80U of { (a1_a80X [Occ=Once], s'_a80Y [Occ=Once]) ->
(Zepto.$WOK @ a_X7Gc a1_a80X s_i7ZK, s'_a80Y)
})
(>>=
@ m_X7Ga
$dMonad_X7Gf
@ a_X7Gc
@ (a_X7Gc, Point)
m1_X4Fb
(\ (a1_a80G [Occ=Once] :: a_X7Gc) ->
return
@ m_X7Ga $dMonad_X7Gf @ (a_X7Gc, Point) (a1_a80G, s1_a80T))))
`cast` ((<Zepto.S>_R
->_R Sym (Control.Monad.Trans.State.Strict.N:StateT[0]
<Point>_N
<m_X7Ga>_R
<Zepto.Result a_X7Gc>_N)) ; (Sym (Zepto.N:ZeptoT[0]
<StateT
Point m_X7Ga>_R
<a_X7Gc>_N) ; Sym (Main.N:P[0]
<m_X7Ga>_R) <a_X7Gc>_N)
:: (Zepto.S -> Point -> m_X7Ga (Zepto.Result a_X7Gc, Point) :: *)
~R# (P m_X7Ga a_X7Gc :: *))}]
Main.$fMonadTransP_$clift
= $clift_rcC8
`cast` (forall (m :: <* -> *>_N) (a :: <*>_N).
<Monad m>_R
->_R <m a>_R
->_R (<Zepto.S>_R
->_R Sym (Control.Monad.Trans.State.Strict.N:StateT[0]
<Point>_N <m>_R <Zepto.Result a>_N)) ; (Sym (Zepto.N:ZeptoT[0]
<StateT Point m>_R
<a>_N) ; Sym (Main.N:P[0]
<m>_R) <a>_N)
:: (forall (m :: * -> *) a.
Monad m =>
m a -> Zepto.S -> Point -> m (Zepto.Result a, Point) :: *)
~R# (forall (m :: * -> *) a. Monad m => m a -> P m a :: *))
-- RHS size: {terms: 1, types: 0, coercions: 3, joins: 0/0}
Main.$fMonadTransP [InlPrag=INLINE (sat-args=0)] :: MonadTrans P
[GblId[DFunId(nt)],
Arity=4,
Caf=NoCafRefs,
Str=<S(S(S(C(C(S))L)LLLLL)LLLL),U(1*U(1*U(1*C1(C1(U)),A),A,A,A,A,A),1*C1(C1(U)),A,C(U),A)><L,U><L,U><L,U>,
Unf=Unf{Src=InlineStable, TopLvl=True, Value=True, ConLike=True,
WorkFree=True, Expandable=True,
Guidance=ALWAYS_IF(arity=0,unsat_ok=False,boring_ok=True)
Tmpl= Main.$fMonadTransP_$clift
`cast` (Sym (Control.Monad.Trans.Class.N:MonadTrans[0] <P>_N)
:: (forall (m :: * -> *) a. Monad m => m a -> P m a :: *)
~R# (MonadTrans P :: Constraint))}]
Main.$fMonadTransP
= Main.$fMonadTransP_$clift
`cast` (Sym (Control.Monad.Trans.Class.N:MonadTrans[0] <P>_N)
:: (forall (m :: * -> *) a. Monad m => m a -> P m a :: *)
~R# (MonadTrans P :: Constraint))
Linking tok ...
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment