Skip to content

Instantly share code, notes, and snippets.

@mpickering

mpickering/BenchShort.dump-simpl

Created February 7, 2023 13:18
Show Gist options
  • Star 0 You must be signed in to star a gist
  • Fork 0 You must be signed in to fork a gist
  • Save mpickering/81266fa8d046cc98c49bee2fb4822cdd to your computer and use it in GitHub Desktop.
Save mpickering/81266fa8d046cc98c49bee2fb4822cdd to your computer and use it in GitHub Desktop.
Download ZIP
Raw
BenchShort.dump-simpl
==================== Tidy Core ====================
2023-02-07 11:26:44.154644059 UTC
Result size of Tidy Core
= {terms: 1,451, types: 1,335, coercions: 72, joins: 3/46}
-- RHS size: {terms: 1, types: 0, coercions: 0, joins: 0/0}
BenchShort.benchShort12 :: ghc-prim:GHC.Prim.Addr#
[GblId,
Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
WorkFree=True, Expandable=True, Guidance=IF_ARGS [] 70 0}]
BenchShort.benchShort12 = "FindIndex/non-inlined"#
-- RHS size: {terms: 2, types: 0, coercions: 0, joins: 0/0}
BenchShort.benchShort11 :: [Char]
[GblId,
Unf=Unf{Src=<vanilla>, TopLvl=True, Value=False, ConLike=True,
WorkFree=False, Expandable=True, Guidance=IF_ARGS [] 20 0}]
BenchShort.benchShort11
= ghc-prim:GHC.CString.unpackCString# BenchShort.benchShort12
-- RHS size: {terms: 1, types: 0, coercions: 0, joins: 0/0}
BenchShort.benchShort15 :: ghc-prim:GHC.Prim.Addr#
[GblId,
Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
WorkFree=True, Expandable=True, Guidance=IF_ARGS [] 60 0}]
BenchShort.benchShort15 = "FindIndex/inlined"#
-- RHS size: {terms: 2, types: 0, coercions: 0, joins: 0/0}
BenchShort.benchShort14 :: [Char]
[GblId,
Unf=Unf{Src=<vanilla>, TopLvl=True, Value=False, ConLike=True,
WorkFree=False, Expandable=True, Guidance=IF_ARGS [] 20 0}]
BenchShort.benchShort14
= ghc-prim:GHC.CString.unpackCString# BenchShort.benchShort15
-- RHS size: {terms: 1, types: 0, coercions: 0, joins: 0/0}
BenchShort.benchShort21 :: ghc-prim:GHC.Prim.Addr#
[GblId,
Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
WorkFree=True, Expandable=True, Guidance=IF_ARGS [] 70 0}]
BenchShort.benchShort21 = "FindIndices/non-inlined"#
-- RHS size: {terms: 2, types: 0, coercions: 0, joins: 0/0}
BenchShort.benchShort20 :: [Char]
[GblId,
Unf=Unf{Src=<vanilla>, TopLvl=True, Value=False, ConLike=True,
WorkFree=False, Expandable=True, Guidance=IF_ARGS [] 20 0}]
BenchShort.benchShort20
= ghc-prim:GHC.CString.unpackCString# BenchShort.benchShort21
-- RHS size: {terms: 1, types: 0, coercions: 0, joins: 0/0}
BenchShort.benchShort26 :: ghc-prim:GHC.Prim.Addr#
[GblId,
Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
WorkFree=True, Expandable=True, Guidance=IF_ARGS [] 60 0}]
BenchShort.benchShort26 = "FindIndices/inlined"#
-- RHS size: {terms: 2, types: 0, coercions: 0, joins: 0/0}
BenchShort.benchShort25 :: [Char]
[GblId,
Unf=Unf{Src=<vanilla>, TopLvl=True, Value=False, ConLike=True,
WorkFree=False, Expandable=True, Guidance=IF_ARGS [] 20 0}]
BenchShort.benchShort25
= ghc-prim:GHC.CString.unpackCString# BenchShort.benchShort26
-- RHS size: {terms: 1, types: 0, coercions: 0, joins: 0/0}
BenchShort.benchShort28 :: ghc-prim:GHC.Prim.Addr#
[GblId,
Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
WorkFree=True, Expandable=True, Guidance=IF_ARGS [] 110 0}]
BenchShort.benchShort28
= "ShortByteString index equality inlining"#
-- RHS size: {terms: 2, types: 0, coercions: 0, joins: 0/0}
BenchShort.benchShort27 :: [Char]
[GblId,
Unf=Unf{Src=<vanilla>, TopLvl=True, Value=False, ConLike=True,
WorkFree=False, Expandable=True, Guidance=IF_ARGS [] 20 0}]
BenchShort.benchShort27
= ghc-prim:GHC.CString.unpackCString# BenchShort.benchShort28
-- RHS size: {terms: 1, types: 0, coercions: 0, joins: 0/0}
BenchShort.benchShort36 :: ghc-prim:GHC.Prim.Addr#
[GblId,
Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
WorkFree=True, Expandable=True, Guidance=IF_ARGS [] 40 0}]
BenchShort.benchShort36 = "ElemIndex"#
-- RHS size: {terms: 2, types: 0, coercions: 0, joins: 0/0}
BenchShort.benchShort35 :: [Char]
[GblId,
Unf=Unf{Src=<vanilla>, TopLvl=True, Value=False, ConLike=True,
WorkFree=False, Expandable=True, Guidance=IF_ARGS [] 20 0}]
BenchShort.benchShort35
= ghc-prim:GHC.CString.unpackCString# BenchShort.benchShort36
-- RHS size: {terms: 1, types: 0, coercions: 0, joins: 0/0}
BenchShort.benchShort39 :: ghc-prim:GHC.Prim.Addr#
[GblId,
Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
WorkFree=True, Expandable=True, Guidance=IF_ARGS [] 40 0}]
BenchShort.benchShort39 = "FindIndex"#
-- RHS size: {terms: 2, types: 0, coercions: 0, joins: 0/0}
BenchShort.benchShort38 :: [Char]
[GblId,
Unf=Unf{Src=<vanilla>, TopLvl=True, Value=False, ConLike=True,
WorkFree=False, Expandable=True, Guidance=IF_ARGS [] 20 0}]
BenchShort.benchShort38
= ghc-prim:GHC.CString.unpackCString# BenchShort.benchShort39
-- RHS size: {terms: 1, types: 0, coercions: 0, joins: 0/0}
BenchShort.benchShort43 :: ghc-prim:GHC.Prim.Addr#
[GblId,
Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
WorkFree=True, Expandable=True, Guidance=IF_ARGS [] 40 0}]
BenchShort.benchShort43 = "FindIndices"#
-- RHS size: {terms: 2, types: 0, coercions: 0, joins: 0/0}
BenchShort.benchShort42 :: [Char]
[GblId,
Unf=Unf{Src=<vanilla>, TopLvl=True, Value=False, ConLike=True,
WorkFree=False, Expandable=True, Guidance=IF_ARGS [] 20 0}]
BenchShort.benchShort42
= ghc-prim:GHC.CString.unpackCString# BenchShort.benchShort43
-- RHS size: {terms: 1, types: 0, coercions: 0, joins: 0/0}
BenchShort.benchShort45 :: ghc-prim:GHC.Prim.Addr#
[GblId,
Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
WorkFree=True, Expandable=True, Guidance=IF_ARGS [] 100 0}]
BenchShort.benchShort45 = "ShortByteString strict first index"#
-- RHS size: {terms: 2, types: 0, coercions: 0, joins: 0/0}
BenchShort.benchShort44 :: [Char]
[GblId,
Unf=Unf{Src=<vanilla>, TopLvl=True, Value=False, ConLike=True,
WorkFree=False, Expandable=True, Guidance=IF_ARGS [] 20 0}]
BenchShort.benchShort44
= ghc-prim:GHC.CString.unpackCString# BenchShort.benchShort45
-- RHS size: {terms: 2, types: 0, coercions: 0, joins: 0/0}
BenchShort.benchShort18 :: Word8
[GblId,
Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
WorkFree=True, Expandable=True, Guidance=IF_ARGS [] 10 10}]
BenchShort.benchShort18 = GHC.Word.W8# 10##8
-- RHS size: {terms: 36, types: 11, coercions: 0, joins: 0/2}
BenchShort.$weta1 [InlPrag=[2]]
:: ghc-prim:GHC.Prim.ByteArray# -> [Int]
[GblId,
Arity=1,
Str=<L>,
Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
WorkFree=True, Expandable=True, Guidance=IF_ARGS [0] 146 0}]
BenchShort.$weta1
= \ (ww_s4hb :: ghc-prim:GHC.Prim.ByteArray#) ->
let {
l_a4dB :: ghc-prim:GHC.Prim.Int#
[LclId]
l_a4dB = ghc-prim:GHC.Prim.sizeofByteArray# ww_s4hb } in
letrec {
$sgo_a4dC [Occ=LoopBreaker, Dmd=SCS(L)]
:: ghc-prim:GHC.Prim.Int# -> [Int]
[LclId, Arity=1, Str=<L>, Unf=OtherCon []]
$sgo_a4dC
= \ (sc_a4dD :: ghc-prim:GHC.Prim.Int#) ->
case ghc-prim:GHC.Prim.>=# sc_a4dD l_a4dB of {
__DEFAULT ->
case ghc-prim:GHC.Prim.indexWord8Array# ww_s4hb sc_a4dD
of wild_a4dF
{ __DEFAULT ->
case ghc-prim:GHC.Prim.word8ToWord# wild_a4dF of {
__DEFAULT -> $sgo_a4dC (ghc-prim:GHC.Prim.+# sc_a4dD 1#);
10## ->
ghc-prim:GHC.Types.:
@Int
(ghc-prim:GHC.Types.I# sc_a4dD)
($sgo_a4dC (ghc-prim:GHC.Prim.+# sc_a4dD 1#))
}
};
1# -> ghc-prim:GHC.Types.[] @Int
}; } in
$sgo_a4dC 0#
-- RHS size: {terms: 6, types: 3, coercions: 1, joins: 0/0}
BenchShort.benchShort_eta1 [InlPrag=[2]]
:: ShortByteString -> [Int]
[GblId,
Arity=1,
Str=<1!P(L)>,
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= \ (sbs_s4h9 [Occ=Once1!] :: ShortByteString) ->
case sbs_s4h9
`cast` (Data.ByteString.Short.Internal.N:ShortByteString[0]
:: ShortByteString ~R# Data.Array.Byte.ByteArray)
of
{ Data.Array.Byte.ByteArray ww_s4hb [Occ=Once1] ->
BenchShort.$weta1 ww_s4hb
}}]
BenchShort.benchShort_eta1
= \ (sbs_s4h9 :: ShortByteString) ->
case sbs_s4h9
`cast` (Data.ByteString.Short.Internal.N:ShortByteString[0]
:: ShortByteString ~R# Data.Array.Byte.ByteArray)
of
{ Data.Array.Byte.ByteArray ww_s4hb ->
BenchShort.$weta1 ww_s4hb
}
-- RHS size: {terms: 25, types: 15, coercions: 1, joins: 0/0}
BenchShort.benchShort_eta2 :: ShortByteString -> Maybe Int
[GblId,
Arity=1,
Str=<1!P(L)>,
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= \ (sbs_a44O [Occ=Once1!] :: ShortByteString) ->
case sbs_a44O
`cast` (Data.ByteString.Short.Internal.N:ShortByteString[0]
:: ShortByteString ~R# Data.Array.Byte.ByteArray)
of
{ Data.Array.Byte.ByteArray ba#_a44Q ->
case {__ffi_static_ccall_unsafe bytestring-0.11.3.1-inplace:sbs_elem_index :: ByteArray#
-> Word8#
-> Word64#
-> State# RealWorld
-> (# State# RealWorld,
Int64# #)}_a44T
ba#_a44Q
10##8
(ghc-prim:GHC.Prim.int64ToWord64#
(ghc-prim:GHC.Prim.intToInt64#
(ghc-prim:GHC.Prim.sizeofByteArray# ba#_a44Q)))
ghc-prim:GHC.Prim.realWorld#
of
{ (# _ [Occ=Dead], ds3_a44Y #) ->
case ghc-prim:GHC.Prim.ltInt64# ds3_a44Y 0#64 of {
__DEFAULT ->
GHC.Maybe.Just
@Int
(ghc-prim:GHC.Types.I# (ghc-prim:GHC.Prim.int64ToInt# ds3_a44Y));
1# -> GHC.Maybe.Nothing @Int
}
}
}}]
BenchShort.benchShort_eta2
= \ (sbs_a44O :: ShortByteString) ->
case sbs_a44O
`cast` (Data.ByteString.Short.Internal.N:ShortByteString[0]
:: ShortByteString ~R# Data.Array.Byte.ByteArray)
of
{ Data.Array.Byte.ByteArray ba#_a44Q ->
case {__ffi_static_ccall_unsafe bytestring-0.11.3.1-inplace:sbs_elem_index :: ByteArray#
-> Word8#
-> Word64#
-> State# RealWorld
-> (# State# RealWorld,
Int64# #)}_a44T
ba#_a44Q
10##8
(ghc-prim:GHC.Prim.int64ToWord64#
(ghc-prim:GHC.Prim.intToInt64#
(ghc-prim:GHC.Prim.sizeofByteArray# ba#_a44Q)))
ghc-prim:GHC.Prim.realWorld#
of
{ (# ds2_a44X, ds3_a44Y #) ->
case ghc-prim:GHC.Prim.ltInt64# ds3_a44Y 0#64 of {
__DEFAULT ->
GHC.Maybe.Just
@Int
(ghc-prim:GHC.Types.I# (ghc-prim:GHC.Prim.int64ToInt# ds3_a44Y));
1# -> GHC.Maybe.Nothing @Int
}
}
}
-- RHS size: {terms: 42, types: 18, coercions: 0, joins: 0/2}
BenchShort.$weta2 [InlPrag=[2]]
:: ghc-prim:GHC.Prim.ByteArray# -> Maybe Int
[GblId,
Arity=1,
Str=<L>,
Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
WorkFree=True, Expandable=True, Guidance=IF_ARGS [0] 176 20}]
BenchShort.$weta2
= \ (ww_s4fZ :: ghc-prim:GHC.Prim.ByteArray#) ->
let {
l_a4dB :: ghc-prim:GHC.Prim.Int#
[LclId]
l_a4dB = ghc-prim:GHC.Prim.sizeofByteArray# ww_s4fZ } in
letrec {
$sgo_a4dC [Occ=LoopBreaker, Dmd=SCS(L)]
:: ghc-prim:GHC.Prim.Int# -> [Int]
[LclId, Arity=1, Str=<L>, Unf=OtherCon []]
$sgo_a4dC
= \ (sc_a4dD :: ghc-prim:GHC.Prim.Int#) ->
case ghc-prim:GHC.Prim.>=# sc_a4dD l_a4dB of {
__DEFAULT ->
case ghc-prim:GHC.Prim.indexWord8Array# ww_s4fZ sc_a4dD
of wild_a4dF
{ __DEFAULT ->
case ghc-prim:GHC.Prim.word8ToWord# wild_a4dF of {
__DEFAULT -> $sgo_a4dC (ghc-prim:GHC.Prim.+# sc_a4dD 1#);
10## ->
ghc-prim:GHC.Types.:
@Int
(ghc-prim:GHC.Types.I# sc_a4dD)
($sgo_a4dC (ghc-prim:GHC.Prim.+# sc_a4dD 1#))
}
};
1# -> ghc-prim:GHC.Types.[] @Int
}; } in
case $sgo_a4dC 0# of {
[] -> GHC.Maybe.Nothing @Int;
: y_i4fy ys_i4fz -> GHC.Maybe.Just @Int y_i4fy
}
-- RHS size: {terms: 6, types: 3, coercions: 1, joins: 0/0}
BenchShort.benchShort_eta3 [InlPrag=[2]]
:: ShortByteString -> Maybe Int
[GblId,
Arity=1,
Str=<1!P(L)>,
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_s4fX [Occ=Once1!] :: ShortByteString) ->
case x_s4fX
`cast` (Data.ByteString.Short.Internal.N:ShortByteString[0]
:: ShortByteString ~R# Data.Array.Byte.ByteArray)
of
{ Data.Array.Byte.ByteArray ww_s4fZ [Occ=Once1] ->
BenchShort.$weta2 ww_s4fZ
}}]
BenchShort.benchShort_eta3
= \ (x_s4fX :: ShortByteString) ->
case x_s4fX
`cast` (Data.ByteString.Short.Internal.N:ShortByteString[0]
:: ShortByteString ~R# Data.Array.Byte.ByteArray)
of
{ Data.Array.Byte.ByteArray ww_s4fZ ->
BenchShort.$weta2 ww_s4fZ
}
-- RHS size: {terms: 1, types: 0, coercions: 0, joins: 0/0}
BenchShort.benchShort47 :: ghc-prim:GHC.Prim.Addr#
[GblId,
Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
WorkFree=True, Expandable=True, Guidance=IF_ARGS [] 50 0}]
BenchShort.benchShort47 = "ShortByteString"#
-- RHS size: {terms: 2, types: 0, coercions: 0, joins: 0/0}
BenchShort.benchShort46 :: [Char]
[GblId,
Unf=Unf{Src=<vanilla>, TopLvl=True, Value=False, ConLike=True,
WorkFree=False, Expandable=True, Guidance=IF_ARGS [] 20 0}]
BenchShort.benchShort46
= ghc-prim:GHC.CString.unpackCString# BenchShort.benchShort47
-- RHS size: {terms: 1, types: 0, coercions: 0, joins: 0/0}
nilEq [InlPrag=NOINLINE] :: Word8 -> Word8 -> Bool
[GblId, Arity=2, Str=<1!P(L)><1!P(L)>, Unf=OtherCon []]
nilEq = GHC.Word.eqWord8
-- RHS size: {terms: 38, types: 11, coercions: 0, joins: 0/2}
BenchShort.$weta [InlPrag=[2]]
:: ghc-prim:GHC.Prim.ByteArray# -> [Int]
[GblId,
Arity=1,
Str=<L>,
Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
WorkFree=True, Expandable=True, Guidance=IF_ARGS [0] 185 0}]
BenchShort.$weta
= \ (ww_s4hA :: ghc-prim:GHC.Prim.ByteArray#) ->
let {
l_a4dB :: ghc-prim:GHC.Prim.Int#
[LclId]
l_a4dB = ghc-prim:GHC.Prim.sizeofByteArray# ww_s4hA } in
letrec {
$sgo_a4dC [Occ=LoopBreaker, Dmd=SCS(L)]
:: ghc-prim:GHC.Prim.Int# -> [Int]
[LclId, Arity=1, Str=<L>, Unf=OtherCon []]
$sgo_a4dC
= \ (sc_a4dD :: ghc-prim:GHC.Prim.Int#) ->
case ghc-prim:GHC.Prim.>=# sc_a4dD l_a4dB of {
__DEFAULT ->
case ghc-prim:GHC.Prim.indexWord8Array# ww_s4hA sc_a4dD
of wild_a4dF
{ __DEFAULT ->
case nilEq BenchShort.benchShort18 (GHC.Word.W8# wild_a4dF) of {
False -> $sgo_a4dC (ghc-prim:GHC.Prim.+# sc_a4dD 1#);
True ->
ghc-prim:GHC.Types.:
@Int
(ghc-prim:GHC.Types.I# sc_a4dD)
($sgo_a4dC (ghc-prim:GHC.Prim.+# sc_a4dD 1#))
}
};
1# -> ghc-prim:GHC.Types.[] @Int
}; } in
$sgo_a4dC 0#
-- RHS size: {terms: 6, types: 3, coercions: 1, joins: 0/0}
BenchShort.benchShort_eta [InlPrag=[2]] :: ShortByteString -> [Int]
[GblId,
Arity=1,
Str=<1!P(L)>,
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= \ (sbs_s4hy [Occ=Once1!] :: ShortByteString) ->
case sbs_s4hy
`cast` (Data.ByteString.Short.Internal.N:ShortByteString[0]
:: ShortByteString ~R# Data.Array.Byte.ByteArray)
of
{ Data.Array.Byte.ByteArray ww_s4hA [Occ=Once1] ->
BenchShort.$weta ww_s4hA
}}]
BenchShort.benchShort_eta
= \ (sbs_s4hy :: ShortByteString) ->
case sbs_s4hy
`cast` (Data.ByteString.Short.Internal.N:ShortByteString[0]
:: ShortByteString ~R# Data.Array.Byte.ByteArray)
of
{ Data.Array.Byte.ByteArray ww_s4hA ->
BenchShort.$weta ww_s4hA
}
-- RHS size: {terms: 697, types: 689, coercions: 2, joins: 0/30}
absurdlong :: ShortByteString
[GblId]
absurdlong
= ghc-prim:GHC.Magic.runRW#
@ghc-prim:GHC.Types.LiftedRep
@ShortByteString
(\ (s_a404 [OS=OneShot]
:: ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld) ->
case ghc-prim:GHC.Prim.newByteArray#
@ghc-prim:GHC.Prim.RealWorld 999999# s_a404
of
{ (# ipv_a406, ipv1_a407 #) ->
case ghc-prim:GHC.Prim.setByteArray#
@ghc-prim:GHC.Prim.RealWorld ipv1_a407 0# 999999# 102# ipv_a406
of s'_a40c
{ __DEFAULT ->
case ghc-prim:GHC.Prim.unsafeFreezeByteArray#
@ghc-prim:GHC.Prim.RealWorld ipv1_a407 s'_a40c
of
{ (# ipv2_a40e, ipv3_a40f #) ->
ghc-prim:GHC.Magic.runRW#
@ghc-prim:GHC.Types.LiftedRep
@ShortByteString
(\ (s1_a40j [OS=OneShot]
:: ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld) ->
case ghc-prim:GHC.Prim.newByteArray#
@ghc-prim:GHC.Prim.RealWorld 1# s1_a40j
of
{ (# ipv4_a40l, ipv5_a40m #) ->
case ghc-prim:GHC.Prim.writeWord8Array#
@ghc-prim:GHC.Prim.RealWorld ipv5_a40m 0# 10##8 ipv4_a40l
of s'1_a40r
{ __DEFAULT ->
case ghc-prim:GHC.Prim.unsafeFreezeByteArray#
@ghc-prim:GHC.Prim.RealWorld ipv5_a40m s'1_a40r
of
{ (# ipv6_a40t, ipv7_a40u #) ->
ghc-prim:GHC.Magic.runRW#
@ghc-prim:GHC.Types.LiftedRep
@ShortByteString
(\ (s2_a3ZH [OS=OneShot]
:: ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld) ->
let {
ipv8_s4b1 :: ghc-prim:GHC.Prim.Int#
[LclId]
ipv8_s4b1 = ghc-prim:GHC.Prim.sizeofByteArray# ipv7_a40u } in
let {
ipv9_s4b0 :: ghc-prim:GHC.Prim.Int#
[LclId]
ipv9_s4b0 = ghc-prim:GHC.Prim.sizeofByteArray# ipv3_a40f } in
let {
r_s4aZ :: ghc-prim:GHC.Prim.Int#
[LclId]
r_s4aZ = ghc-prim:GHC.Prim.+# ipv8_s4b1 ipv9_s4b0 } in
case ghc-prim:GHC.Prim.>=# r_s4aZ 0# of {
__DEFAULT ->
case Data.ByteString.Short.Internal.append1 of wild_00 { };
1# ->
case ghc-prim:GHC.Prim.newByteArray#
@ghc-prim:GHC.Prim.RealWorld r_s4aZ s2_a3ZH
of
{ (# ipv10_a3ZP, ipv11_a3ZQ #) ->
case ghc-prim:GHC.Prim.copyByteArray#
@ghc-prim:GHC.Prim.RealWorld
ipv7_a40u
0#
ipv11_a3ZQ
0#
ipv8_s4b1
ipv10_a3ZP
of s'2_a3ZS
{ __DEFAULT ->
case ghc-prim:GHC.Prim.copyByteArray#
@ghc-prim:GHC.Prim.RealWorld
ipv3_a40f
0#
ipv11_a3ZQ
ipv8_s4b1
ipv9_s4b0
s'2_a3ZS
of s'3_a3ZT
{ __DEFAULT ->
case ghc-prim:GHC.Prim.unsafeFreezeByteArray#
@ghc-prim:GHC.Prim.RealWorld ipv11_a3ZQ s'3_a3ZT
of
{ (# ipv12_a3ZV, ipv13_a3ZW #) ->
ghc-prim:GHC.Magic.runRW#
@ghc-prim:GHC.Types.LiftedRep
@ShortByteString
(\ (s3_X1 [OS=OneShot]
:: ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld) ->
case ghc-prim:GHC.Prim.newByteArray#
@ghc-prim:GHC.Prim.RealWorld 200# s3_X1
of
{ (# ipv14_X3, ipv15_X4 #) ->
case ghc-prim:GHC.Prim.setByteArray#
@ghc-prim:GHC.Prim.RealWorld ipv15_X4 0# 200# 101# ipv14_X3
of s'4_X5
{ __DEFAULT ->
case ghc-prim:GHC.Prim.unsafeFreezeByteArray#
@ghc-prim:GHC.Prim.RealWorld ipv15_X4 s'4_X5
of
{ (# ipv16_X7, ipv17_X8 #) ->
ghc-prim:GHC.Magic.runRW#
@ghc-prim:GHC.Types.LiftedRep
@ShortByteString
(\ (s4_X9 [OS=OneShot]
:: ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld) ->
let {
ipv18_s4aY :: ghc-prim:GHC.Prim.Int#
[LclId]
ipv18_s4aY = ghc-prim:GHC.Prim.sizeofByteArray# ipv17_X8 } in
let {
ipv19_s4aX :: ghc-prim:GHC.Prim.Int#
[LclId]
ipv19_s4aX = ghc-prim:GHC.Prim.sizeofByteArray# ipv13_a3ZW } in
let {
r1_s4aW :: ghc-prim:GHC.Prim.Int#
[LclId]
r1_s4aW = ghc-prim:GHC.Prim.+# ipv18_s4aY ipv19_s4aX } in
case ghc-prim:GHC.Prim.>=# r1_s4aW 0# of {
__DEFAULT ->
case Data.ByteString.Short.Internal.append1 of wild_00 { };
1# ->
case ghc-prim:GHC.Prim.newByteArray#
@ghc-prim:GHC.Prim.RealWorld r1_s4aW s4_X9
of
{ (# ipv20_Xc, ipv21_Xd #) ->
case ghc-prim:GHC.Prim.copyByteArray#
@ghc-prim:GHC.Prim.RealWorld
ipv17_X8
0#
ipv21_Xd
0#
ipv18_s4aY
ipv20_Xc
of s'5_Xe
{ __DEFAULT ->
case ghc-prim:GHC.Prim.copyByteArray#
@ghc-prim:GHC.Prim.RealWorld
ipv13_a3ZW
0#
ipv21_Xd
ipv18_s4aY
ipv19_s4aX
s'5_Xe
of s'6_Xf
{ __DEFAULT ->
case ghc-prim:GHC.Prim.unsafeFreezeByteArray#
@ghc-prim:GHC.Prim.RealWorld ipv21_Xd s'6_Xf
of
{ (# ipv22_Xh, ipv23_Xi #) ->
ghc-prim:GHC.Magic.runRW#
@ghc-prim:GHC.Types.LiftedRep
@ShortByteString
(\ (s5_Xj [OS=OneShot]
:: ghc-prim:GHC.Prim.State#
ghc-prim:GHC.Prim.RealWorld) ->
case ghc-prim:GHC.Prim.newByteArray#
@ghc-prim:GHC.Prim.RealWorld 1# s5_Xj
of
{ (# ipv24_Xl, ipv25_Xm #) ->
case ghc-prim:GHC.Prim.writeWord8Array#
@ghc-prim:GHC.Prim.RealWorld
ipv25_Xm
0#
10##8
ipv24_Xl
of s'7_Xn
{ __DEFAULT ->
case ghc-prim:GHC.Prim.unsafeFreezeByteArray#
@ghc-prim:GHC.Prim.RealWorld ipv25_Xm s'7_Xn
of
{ (# ipv26_Xp, ipv27_Xq #) ->
ghc-prim:GHC.Magic.runRW#
@ghc-prim:GHC.Types.LiftedRep
@ShortByteString
(\ (s6_Xr [OS=OneShot]
:: ghc-prim:GHC.Prim.State#
ghc-prim:GHC.Prim.RealWorld) ->
let {
ipv28_s4b7 :: ghc-prim:GHC.Prim.Int#
[LclId]
ipv28_s4b7
= ghc-prim:GHC.Prim.sizeofByteArray#
ipv27_Xq } in
let {
ipv29_s4b6 :: ghc-prim:GHC.Prim.Int#
[LclId]
ipv29_s4b6
= ghc-prim:GHC.Prim.sizeofByteArray#
ipv23_Xi } in
let {
r2_s4b5 :: ghc-prim:GHC.Prim.Int#
[LclId]
r2_s4b5
= ghc-prim:GHC.Prim.+# ipv28_s4b7 ipv29_s4b6 } in
case ghc-prim:GHC.Prim.>=# r2_s4b5 0# of {
__DEFAULT ->
case Data.ByteString.Short.Internal.append1
of wild_00 {
};
1# ->
case ghc-prim:GHC.Prim.newByteArray#
@ghc-prim:GHC.Prim.RealWorld r2_s4b5 s6_Xr
of
{ (# ipv30_Xu, ipv31_Xv #) ->
case ghc-prim:GHC.Prim.copyByteArray#
@ghc-prim:GHC.Prim.RealWorld
ipv27_Xq
0#
ipv31_Xv
0#
ipv28_s4b7
ipv30_Xu
of s'8_Xw
{ __DEFAULT ->
case ghc-prim:GHC.Prim.copyByteArray#
@ghc-prim:GHC.Prim.RealWorld
ipv23_Xi
0#
ipv31_Xv
ipv28_s4b7
ipv29_s4b6
s'8_Xw
of s'9_Xx
{ __DEFAULT ->
case ghc-prim:GHC.Prim.unsafeFreezeByteArray#
@ghc-prim:GHC.Prim.RealWorld
ipv31_Xv
s'9_Xx
of
{ (# ipv32_Xz, ipv33_XA #) ->
ghc-prim:GHC.Magic.runRW#
@ghc-prim:GHC.Types.LiftedRep
@ShortByteString
(\ (s7_XB [OS=OneShot]
:: ghc-prim:GHC.Prim.State#
ghc-prim:GHC.Prim.RealWorld) ->
case ghc-prim:GHC.Prim.newByteArray#
@ghc-prim:GHC.Prim.RealWorld
200#
s7_XB
of
{ (# ipv34_XD, ipv35_XE #) ->
case ghc-prim:GHC.Prim.setByteArray#
@ghc-prim:GHC.Prim.RealWorld
ipv35_XE
0#
200#
100#
ipv34_XD
of s'10_XF
{ __DEFAULT ->
case ghc-prim:GHC.Prim.unsafeFreezeByteArray#
@ghc-prim:GHC.Prim.RealWorld
ipv35_XE
s'10_XF
of
{ (# ipv36_XH, ipv37_XI #) ->
ghc-prim:GHC.Magic.runRW#
@ghc-prim:GHC.Types.LiftedRep
@ShortByteString
(\ (s8_XJ [OS=OneShot]
:: ghc-prim:GHC.Prim.State#
ghc-prim:GHC.Prim.RealWorld) ->
let {
ipv38_s4bd :: ghc-prim:GHC.Prim.Int#
[LclId]
ipv38_s4bd
= ghc-prim:GHC.Prim.sizeofByteArray#
ipv37_XI } in
let {
ipv39_s4bc :: ghc-prim:GHC.Prim.Int#
[LclId]
ipv39_s4bc
= ghc-prim:GHC.Prim.sizeofByteArray#
ipv33_XA } in
let {
r3_s4bb :: ghc-prim:GHC.Prim.Int#
[LclId]
r3_s4bb
= ghc-prim:GHC.Prim.+#
ipv38_s4bd ipv39_s4bc } in
case ghc-prim:GHC.Prim.>=# r3_s4bb 0#
of {
__DEFAULT ->
case Data.ByteString.Short.Internal.append1
of wild_00 {
};
1# ->
case ghc-prim:GHC.Prim.newByteArray#
@ghc-prim:GHC.Prim.RealWorld
r3_s4bb
s8_XJ
of
{ (# ipv40_XM, ipv41_XN #) ->
case ghc-prim:GHC.Prim.copyByteArray#
@ghc-prim:GHC.Prim.RealWorld
ipv37_XI
0#
ipv41_XN
0#
ipv38_s4bd
ipv40_XM
of s'11_XO
{ __DEFAULT ->
case ghc-prim:GHC.Prim.copyByteArray#
@ghc-prim:GHC.Prim.RealWorld
ipv33_XA
0#
ipv41_XN
ipv38_s4bd
ipv39_s4bc
s'11_XO
of s'12_XP
{ __DEFAULT ->
case ghc-prim:GHC.Prim.unsafeFreezeByteArray#
@ghc-prim:GHC.Prim.RealWorld
ipv41_XN
s'12_XP
of
{ (# ipv42_XR, ipv43_XS #) ->
ghc-prim:GHC.Magic.runRW#
@ghc-prim:GHC.Types.LiftedRep
@ShortByteString
(\ (s9_XT [OS=OneShot]
:: ghc-prim:GHC.Prim.State#
ghc-prim:GHC.Prim.RealWorld) ->
case ghc-prim:GHC.Prim.newByteArray#
@ghc-prim:GHC.Prim.RealWorld
1#
s9_XT
of
{ (# ipv44_XV, ipv45_XW #) ->
case ghc-prim:GHC.Prim.writeWord8Array#
@ghc-prim:GHC.Prim.RealWorld
ipv45_XW
0#
10##8
ipv44_XV
of s'13_XX
{ __DEFAULT ->
case ghc-prim:GHC.Prim.unsafeFreezeByteArray#
@ghc-prim:GHC.Prim.RealWorld
ipv45_XW
s'13_XX
of
{ (# ipv46_XZ, ipv47_X10 #) ->
ghc-prim:GHC.Magic.runRW#
@ghc-prim:GHC.Types.LiftedRep
@ShortByteString
(\ (s10_X11 [OS=OneShot]
:: ghc-prim:GHC.Prim.State#
ghc-prim:GHC.Prim.RealWorld) ->
let {
ipv48_s4bj
:: ghc-prim:GHC.Prim.Int#
[LclId]
ipv48_s4bj
= ghc-prim:GHC.Prim.sizeofByteArray#
ipv47_X10 } in
let {
ipv49_s4bi
:: ghc-prim:GHC.Prim.Int#
[LclId]
ipv49_s4bi
= ghc-prim:GHC.Prim.sizeofByteArray#
ipv43_XS } in
let {
r4_s4bh
:: ghc-prim:GHC.Prim.Int#
[LclId]
r4_s4bh
= ghc-prim:GHC.Prim.+#
ipv48_s4bj
ipv49_s4bi } in
case ghc-prim:GHC.Prim.>=#
r4_s4bh 0#
of {
__DEFAULT ->
case Data.ByteString.Short.Internal.append1
of wild_00 {
};
1# ->
case ghc-prim:GHC.Prim.newByteArray#
@ghc-prim:GHC.Prim.RealWorld
r4_s4bh
s10_X11
of
{ (# ipv50_X14,
ipv51_X15 #) ->
case ghc-prim:GHC.Prim.copyByteArray#
@ghc-prim:GHC.Prim.RealWorld
ipv47_X10
0#
ipv51_X15
0#
ipv48_s4bj
ipv50_X14
of s'14_X16
{ __DEFAULT ->
case ghc-prim:GHC.Prim.copyByteArray#
@ghc-prim:GHC.Prim.RealWorld
ipv43_XS
0#
ipv51_X15
ipv48_s4bj
ipv49_s4bi
s'14_X16
of s'15_X17
{ __DEFAULT ->
case ghc-prim:GHC.Prim.unsafeFreezeByteArray#
@ghc-prim:GHC.Prim.RealWorld
ipv51_X15
s'15_X17
of
{ (# ipv52_X19,
ipv53_X1a #) ->
ghc-prim:GHC.Magic.runRW#
@ghc-prim:GHC.Types.LiftedRep
@ShortByteString
(\ (s11_X1b [OS=OneShot]
:: ghc-prim:GHC.Prim.State#
ghc-prim:GHC.Prim.RealWorld) ->
case ghc-prim:GHC.Prim.newByteArray#
@ghc-prim:GHC.Prim.RealWorld
200#
s11_X1b
of
{ (# ipv54_X1d,
ipv55_X1e #) ->
case ghc-prim:GHC.Prim.setByteArray#
@ghc-prim:GHC.Prim.RealWorld
ipv55_X1e
0#
200#
99#
ipv54_X1d
of s'16_X1f
{ __DEFAULT ->
case ghc-prim:GHC.Prim.unsafeFreezeByteArray#
@ghc-prim:GHC.Prim.RealWorld
ipv55_X1e
s'16_X1f
of
{ (# ipv56_X1h,
ipv57_X1i #) ->
ghc-prim:GHC.Magic.runRW#
@ghc-prim:GHC.Types.LiftedRep
@ShortByteString
(\ (s12_X1j [OS=OneShot]
:: ghc-prim:GHC.Prim.State#
ghc-prim:GHC.Prim.RealWorld) ->
let {
ipv58_s4bp
:: ghc-prim:GHC.Prim.Int#
[LclId]
ipv58_s4bp
= ghc-prim:GHC.Prim.sizeofByteArray#
ipv57_X1i } in
let {
ipv59_s4bo
:: ghc-prim:GHC.Prim.Int#
[LclId]
ipv59_s4bo
= ghc-prim:GHC.Prim.sizeofByteArray#
ipv53_X1a } in
let {
r5_s4bn
:: ghc-prim:GHC.Prim.Int#
[LclId]
r5_s4bn
= ghc-prim:GHC.Prim.+#
ipv58_s4bp
ipv59_s4bo } in
case ghc-prim:GHC.Prim.>=#
r5_s4bn
0#
of {
__DEFAULT ->
case Data.ByteString.Short.Internal.append1
of wild_00 {
};
1# ->
case ghc-prim:GHC.Prim.newByteArray#
@ghc-prim:GHC.Prim.RealWorld
r5_s4bn
s12_X1j
of
{ (# ipv60_X1m,
ipv61_X1n #) ->
case ghc-prim:GHC.Prim.copyByteArray#
@ghc-prim:GHC.Prim.RealWorld
ipv57_X1i
0#
ipv61_X1n
0#
ipv58_s4bp
ipv60_X1m
of s'17_X1o
{ __DEFAULT ->
case ghc-prim:GHC.Prim.copyByteArray#
@ghc-prim:GHC.Prim.RealWorld
ipv53_X1a
0#
ipv61_X1n
ipv58_s4bp
ipv59_s4bo
s'17_X1o
of s'18_X1p
{ __DEFAULT ->
case ghc-prim:GHC.Prim.unsafeFreezeByteArray#
@ghc-prim:GHC.Prim.RealWorld
ipv61_X1n
s'18_X1p
of
{ (# ipv62_X1r,
ipv63_X1s #) ->
ghc-prim:GHC.Magic.runRW#
@ghc-prim:GHC.Types.LiftedRep
@ShortByteString
(\ (s13_X1t [OS=OneShot]
:: ghc-prim:GHC.Prim.State#
ghc-prim:GHC.Prim.RealWorld) ->
case ghc-prim:GHC.Prim.newByteArray#
@ghc-prim:GHC.Prim.RealWorld
1#
s13_X1t
of
{ (# ipv64_X1v,
ipv65_X1w #) ->
case ghc-prim:GHC.Prim.writeWord8Array#
@ghc-prim:GHC.Prim.RealWorld
ipv65_X1w
0#
10##8
ipv64_X1v
of s'19_X1x
{ __DEFAULT ->
case ghc-prim:GHC.Prim.unsafeFreezeByteArray#
@ghc-prim:GHC.Prim.RealWorld
ipv65_X1w
s'19_X1x
of
{ (# ipv66_X1z,
ipv67_X1A #) ->
ghc-prim:GHC.Magic.runRW#
@ghc-prim:GHC.Types.LiftedRep
@ShortByteString
(\ (s14_X1B [OS=OneShot]
:: ghc-prim:GHC.Prim.State#
ghc-prim:GHC.Prim.RealWorld) ->
let {
ipv68_s4bv
:: ghc-prim:GHC.Prim.Int#
[LclId]
ipv68_s4bv
= ghc-prim:GHC.Prim.sizeofByteArray#
ipv67_X1A } in
let {
ipv69_s4bu
:: ghc-prim:GHC.Prim.Int#
[LclId]
ipv69_s4bu
= ghc-prim:GHC.Prim.sizeofByteArray#
ipv63_X1s } in
let {
r6_s4bt
:: ghc-prim:GHC.Prim.Int#
[LclId]
r6_s4bt
= ghc-prim:GHC.Prim.+#
ipv68_s4bv
ipv69_s4bu } in
case ghc-prim:GHC.Prim.>=#
r6_s4bt
0#
of {
__DEFAULT ->
case Data.ByteString.Short.Internal.append1
of wild_00 {
};
1# ->
case ghc-prim:GHC.Prim.newByteArray#
@ghc-prim:GHC.Prim.RealWorld
r6_s4bt
s14_X1B
of
{ (# ipv70_X1E,
ipv71_X1F #) ->
case ghc-prim:GHC.Prim.copyByteArray#
@ghc-prim:GHC.Prim.RealWorld
ipv67_X1A
0#
ipv71_X1F
0#
ipv68_s4bv
ipv70_X1E
of s'20_X1G
{ __DEFAULT ->
case ghc-prim:GHC.Prim.copyByteArray#
@ghc-prim:GHC.Prim.RealWorld
ipv63_X1s
0#
ipv71_X1F
ipv68_s4bv
ipv69_s4bu
s'20_X1G
of s'21_X1H
{ __DEFAULT ->
case ghc-prim:GHC.Prim.unsafeFreezeByteArray#
@ghc-prim:GHC.Prim.RealWorld
ipv71_X1F
s'21_X1H
of
{ (# ipv72_X1J,
ipv73_X1K #) ->
ghc-prim:GHC.Magic.runRW#
@ghc-prim:GHC.Types.LiftedRep
@ShortByteString
(\ (s15_X1L [OS=OneShot]
:: ghc-prim:GHC.Prim.State#
ghc-prim:GHC.Prim.RealWorld) ->
case ghc-prim:GHC.Prim.newByteArray#
@ghc-prim:GHC.Prim.RealWorld
200#
s15_X1L
of
{ (# ipv74_X1N,
ipv75_X1O #) ->
case ghc-prim:GHC.Prim.setByteArray#
@ghc-prim:GHC.Prim.RealWorld
ipv75_X1O
0#
200#
98#
ipv74_X1N
of s'22_X1P
{ __DEFAULT ->
case ghc-prim:GHC.Prim.unsafeFreezeByteArray#
@ghc-prim:GHC.Prim.RealWorld
ipv75_X1O
s'22_X1P
of
{ (# ipv76_X1R,
ipv77_X1S #) ->
ghc-prim:GHC.Magic.runRW#
@ghc-prim:GHC.Types.LiftedRep
@ShortByteString
(\ (s16_X1T [OS=OneShot]
:: ghc-prim:GHC.Prim.State#
ghc-prim:GHC.Prim.RealWorld) ->
let {
ipv78_s4bB
:: ghc-prim:GHC.Prim.Int#
[LclId]
ipv78_s4bB
= ghc-prim:GHC.Prim.sizeofByteArray#
ipv77_X1S } in
let {
ipv79_s4bA
:: ghc-prim:GHC.Prim.Int#
[LclId]
ipv79_s4bA
= ghc-prim:GHC.Prim.sizeofByteArray#
ipv73_X1K } in
let {
r7_s4bz
:: ghc-prim:GHC.Prim.Int#
[LclId]
r7_s4bz
= ghc-prim:GHC.Prim.+#
ipv78_s4bB
ipv79_s4bA } in
case ghc-prim:GHC.Prim.>=#
r7_s4bz
0#
of {
__DEFAULT ->
case Data.ByteString.Short.Internal.append1
of wild_00 {
};
1# ->
case ghc-prim:GHC.Prim.newByteArray#
@ghc-prim:GHC.Prim.RealWorld
r7_s4bz
s16_X1T
of
{ (# ipv80_X1W,
ipv81_X1X #) ->
case ghc-prim:GHC.Prim.copyByteArray#
@ghc-prim:GHC.Prim.RealWorld
ipv77_X1S
0#
ipv81_X1X
0#
ipv78_s4bB
ipv80_X1W
of s'23_X1Y
{ __DEFAULT ->
case ghc-prim:GHC.Prim.copyByteArray#
@ghc-prim:GHC.Prim.RealWorld
ipv73_X1K
0#
ipv81_X1X
ipv78_s4bB
ipv79_s4bA
s'23_X1Y
of s'24_X1Z
{ __DEFAULT ->
case ghc-prim:GHC.Prim.unsafeFreezeByteArray#
@ghc-prim:GHC.Prim.RealWorld
ipv81_X1X
s'24_X1Z
of
{ (# ipv82_X21,
ipv83_X22 #) ->
ghc-prim:GHC.Magic.runRW#
@ghc-prim:GHC.Types.LiftedRep
@ShortByteString
(\ (s17_X23 [OS=OneShot]
:: ghc-prim:GHC.Prim.State#
ghc-prim:GHC.Prim.RealWorld) ->
case ghc-prim:GHC.Prim.newByteArray#
@ghc-prim:GHC.Prim.RealWorld
1#
s17_X23
of
{ (# ipv84_X25,
ipv85_X26 #) ->
case ghc-prim:GHC.Prim.writeWord8Array#
@ghc-prim:GHC.Prim.RealWorld
ipv85_X26
0#
10##8
ipv84_X25
of s'25_X27
{ __DEFAULT ->
case ghc-prim:GHC.Prim.unsafeFreezeByteArray#
@ghc-prim:GHC.Prim.RealWorld
ipv85_X26
s'25_X27
of
{ (# ipv86_X29,
ipv87_X2a #) ->
ghc-prim:GHC.Magic.runRW#
@ghc-prim:GHC.Types.LiftedRep
@ShortByteString
(\ (s18_X2b [OS=OneShot]
:: ghc-prim:GHC.Prim.State#
ghc-prim:GHC.Prim.RealWorld) ->
let {
ipv88_s4bH
:: ghc-prim:GHC.Prim.Int#
[LclId]
ipv88_s4bH
= ghc-prim:GHC.Prim.sizeofByteArray#
ipv87_X2a } in
let {
ipv89_s4bG
:: ghc-prim:GHC.Prim.Int#
[LclId]
ipv89_s4bG
= ghc-prim:GHC.Prim.sizeofByteArray#
ipv83_X22 } in
let {
r8_s4bF
:: ghc-prim:GHC.Prim.Int#
[LclId]
r8_s4bF
= ghc-prim:GHC.Prim.+#
ipv88_s4bH
ipv89_s4bG } in
case ghc-prim:GHC.Prim.>=#
r8_s4bF
0#
of {
__DEFAULT ->
case Data.ByteString.Short.Internal.append1
of wild_00 {
};
1# ->
case ghc-prim:GHC.Prim.newByteArray#
@ghc-prim:GHC.Prim.RealWorld
r8_s4bF
s18_X2b
of
{ (# ipv90_X2e,
ipv91_X2f #) ->
case ghc-prim:GHC.Prim.copyByteArray#
@ghc-prim:GHC.Prim.RealWorld
ipv87_X2a
0#
ipv91_X2f
0#
ipv88_s4bH
ipv90_X2e
of s'26_X2g
{ __DEFAULT ->
case ghc-prim:GHC.Prim.copyByteArray#
@ghc-prim:GHC.Prim.RealWorld
ipv83_X22
0#
ipv91_X2f
ipv88_s4bH
ipv89_s4bG
s'26_X2g
of s'27_X2h
{ __DEFAULT ->
case ghc-prim:GHC.Prim.unsafeFreezeByteArray#
@ghc-prim:GHC.Prim.RealWorld
ipv91_X2f
s'27_X2h
of
{ (# ipv92_X2j,
ipv93_X2k #) ->
ghc-prim:GHC.Magic.runRW#
@ghc-prim:GHC.Types.LiftedRep
@ShortByteString
(\ (s19_X2l [OS=OneShot]
:: ghc-prim:GHC.Prim.State#
ghc-prim:GHC.Prim.RealWorld) ->
case ghc-prim:GHC.Prim.newByteArray#
@ghc-prim:GHC.Prim.RealWorld
200#
s19_X2l
of
{ (# ipv94_X2n,
ipv95_X2o #) ->
case ghc-prim:GHC.Prim.setByteArray#
@ghc-prim:GHC.Prim.RealWorld
ipv95_X2o
0#
200#
97#
ipv94_X2n
of s'28_X2p
{ __DEFAULT ->
case ghc-prim:GHC.Prim.unsafeFreezeByteArray#
@ghc-prim:GHC.Prim.RealWorld
ipv95_X2o
s'28_X2p
of
{ (# ipv96_X2r,
ipv97_X2s #) ->
ghc-prim:GHC.Magic.runRW#
@ghc-prim:GHC.Types.LiftedRep
@ShortByteString
(\ (s20_X2t [OS=OneShot]
:: ghc-prim:GHC.Prim.State#
ghc-prim:GHC.Prim.RealWorld) ->
let {
ipv98_s4bN
:: ghc-prim:GHC.Prim.Int#
[LclId]
ipv98_s4bN
= ghc-prim:GHC.Prim.sizeofByteArray#
ipv97_X2s } in
let {
ipv99_s4bM
:: ghc-prim:GHC.Prim.Int#
[LclId]
ipv99_s4bM
= ghc-prim:GHC.Prim.sizeofByteArray#
ipv93_X2k } in
let {
r9_s4bL
:: ghc-prim:GHC.Prim.Int#
[LclId]
r9_s4bL
= ghc-prim:GHC.Prim.+#
ipv98_s4bN
ipv99_s4bM } in
case ghc-prim:GHC.Prim.>=#
r9_s4bL
0#
of {
__DEFAULT ->
case Data.ByteString.Short.Internal.append1
of wild_00 {
};
1# ->
case ghc-prim:GHC.Prim.newByteArray#
@ghc-prim:GHC.Prim.RealWorld
r9_s4bL
s20_X2t
of
{ (# ipv100_X2w,
ipv101_X2x #) ->
case ghc-prim:GHC.Prim.copyByteArray#
@ghc-prim:GHC.Prim.RealWorld
ipv97_X2s
0#
ipv101_X2x
0#
ipv98_s4bN
ipv100_X2w
of s'29_X2y
{ __DEFAULT ->
case ghc-prim:GHC.Prim.copyByteArray#
@ghc-prim:GHC.Prim.RealWorld
ipv93_X2k
0#
ipv101_X2x
ipv98_s4bN
ipv99_s4bM
s'29_X2y
of s'30_X2z
{ __DEFAULT ->
case ghc-prim:GHC.Prim.unsafeFreezeByteArray#
@ghc-prim:GHC.Prim.RealWorld
ipv101_X2x
s'30_X2z
of
{ (# ipv102_X2B,
ipv103_X2C #) ->
(Data.Array.Byte.ByteArray
ipv103_X2C)
`cast` (Sym (Data.ByteString.Short.Internal.N:ShortByteString[0])
:: Data.Array.Byte.ByteArray
~R# ShortByteString)
}
}
}
}
})
}
}
})
}
}
}
}
})
}
}
})
}
}
}
}
})
}
}
})
}
}
}
}
})
}
}
})
}
}
}
}
})
}
}
})
}
}
}
}
})
}
}
})
}
}
}
}
})
}
}
})
}
}
}
}
})
}
}
})
}
}
}
}
})
}
}
})
}
}
}
}
})
}
}
})
}
}
})
-- RHS size: {terms: 32, types: 11, coercions: 0, joins: 1/2}
BenchShort.$wfind_index [InlPrag=[2]]
:: ghc-prim:GHC.Prim.ByteArray# -> Maybe Int
[GblId,
Arity=1,
Str=<L>,
Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
WorkFree=True, Expandable=True, Guidance=IF_ARGS [0] 73 0}]
BenchShort.$wfind_index
= \ (ww_s4fP :: ghc-prim:GHC.Prim.ByteArray#) ->
let {
l_s4jS :: ghc-prim:GHC.Prim.Int#
[LclId]
l_s4jS = ghc-prim:GHC.Prim.sizeofByteArray# ww_s4fP } in
joinrec {
$sgo_s4lf [Occ=LoopBreaker, Dmd=SCS(L)]
:: ghc-prim:GHC.Prim.Int# -> Maybe Int
[LclId[JoinId(1)(Nothing)], Arity=1, Str=<L>, Unf=OtherCon []]
$sgo_s4lf (sc_s4le :: ghc-prim:GHC.Prim.Int#)
= case ghc-prim:GHC.Prim.>=# sc_s4le l_s4jS of {
__DEFAULT ->
case ghc-prim:GHC.Prim.indexWord8Array# ww_s4fP sc_s4le
of wild2_a3St
{ __DEFAULT ->
case ghc-prim:GHC.Prim.word8ToWord# wild2_a3St of {
__DEFAULT -> jump $sgo_s4lf (ghc-prim:GHC.Prim.+# sc_s4le 1#);
10## -> GHC.Maybe.Just @Int (ghc-prim:GHC.Types.I# sc_s4le)
}
};
1# -> GHC.Maybe.Nothing @Int
}; } in
jump $sgo_s4lf 0#
-- RHS size: {terms: 6, types: 3, coercions: 1, joins: 0/0}
find_index [InlPrag=[2]] :: ShortByteString -> Maybe Int
[GblId,
Arity=1,
Str=<1!P(L)>,
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= \ (s_s4fN [Occ=Once1!] :: ShortByteString) ->
case s_s4fN
`cast` (Data.ByteString.Short.Internal.N:ShortByteString[0]
:: ShortByteString ~R# Data.Array.Byte.ByteArray)
of
{ Data.Array.Byte.ByteArray ww_s4fP [Occ=Once1] ->
BenchShort.$wfind_index ww_s4fP
}}]
find_index
= \ (s_s4fN :: ShortByteString) ->
case s_s4fN
`cast` (Data.ByteString.Short.Internal.N:ShortByteString[0]
:: ShortByteString ~R# Data.Array.Byte.ByteArray)
of
{ Data.Array.Byte.ByteArray ww_s4fP ->
BenchShort.$wfind_index ww_s4fP
}
Rec {
-- RHS size: {terms: 66, types: 44, coercions: 1, joins: 2/4}
BenchShort.benchShort_$s$wbenchLoop1 [Occ=LoopBreaker]
:: ShortByteString
-> ghc-prim:GHC.Prim.Word64#
-> ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld
-> ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld
[GblId, Arity=3, Str=<L><1L><L>, Unf=OtherCon []]
BenchShort.benchShort_$s$wbenchLoop1
= \ (x_s4g5 :: ShortByteString)
(ww_s4g8 :: ghc-prim:GHC.Prim.Word64#)
(eta1_s4ga [OS=OneShot]
:: ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld) ->
case ww_s4g8 of wild_X1 {
__DEFAULT ->
case ghc-prim:GHC.Prim.seq#
@(Maybe Int)
@ghc-prim:GHC.Prim.RealWorld
(case x_s4g5
`cast` (Data.ByteString.Short.Internal.N:ShortByteString[0]
:: ShortByteString ~R# Data.Array.Byte.ByteArray)
of
{ Data.Array.Byte.ByteArray ww1_s4gr ->
let {
l_s4jV :: ghc-prim:GHC.Prim.Int#
[LclId]
l_s4jV = ghc-prim:GHC.Prim.sizeofByteArray# ww1_s4gr } in
join {
$j_s4lo [Dmd=LCL(C1(L))] :: Int -> Maybe Int -> Maybe Int
[LclId[JoinId(2)(Just [!, !])], Arity=2, Str=<1!A><1L>]
$j_s4lo (x1_i3Pi [OS=OneShot] :: Int)
(wild2_i3Ph [OS=OneShot] :: Maybe Int)
= case wild2_i3Ph of wild3_X3 { __DEFAULT ->
case x1_i3Pi of { ghc-prim:GHC.Types.I# ipv_i3OX -> wild3_X3 }
} } in
joinrec {
$sgo_s4kD [Occ=LoopBreaker, Dmd=SCS(L)]
:: ghc-prim:GHC.Prim.Int# -> Maybe Int
[LclId[JoinId(1)(Nothing)], Arity=1, Str=<L>, Unf=OtherCon []]
$sgo_s4kD (sc_s4kC :: ghc-prim:GHC.Prim.Int#)
= case ghc-prim:GHC.Prim.>=# sc_s4kC l_s4jV of {
__DEFAULT ->
case ghc-prim:GHC.Prim.indexWord8Array# ww1_s4gr sc_s4kC
of wild2_a3St
{ __DEFAULT ->
case ghc-prim:GHC.Prim.word8ToWord# wild2_a3St of {
__DEFAULT -> jump $sgo_s4kD (ghc-prim:GHC.Prim.+# sc_s4kC 1#);
10## ->
let {
x1_i3Pi [Dmd=SL] :: Int
[LclId, Unf=OtherCon []]
x1_i3Pi = ghc-prim:GHC.Types.I# sc_s4kC } in
jump $j_s4lo x1_i3Pi (GHC.Maybe.Just @Int x1_i3Pi)
}
};
1# -> GHC.Maybe.Nothing @Int
}; } in
jump $sgo_s4kD 0#
})
eta1_s4ga
of
{ (# ipv_i41b, ipv1_i41c #) ->
BenchShort.benchShort_$s$wbenchLoop1
x_s4g5 (ghc-prim:GHC.Prim.subWord64# wild_X1 1##64) ipv_i41b
};
0##64 -> eta1_s4ga
}
end Rec }
Rec {
-- RHS size: {terms: 42, types: 33, coercions: 1, joins: 0/0}
BenchShort.benchShort_$s$wbenchLoop [Occ=LoopBreaker]
:: ShortByteString
-> ghc-prim:GHC.Prim.Word64#
-> ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld
-> ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld
[GblId, Arity=3, Str=<L><1L><L>, Unf=OtherCon []]
BenchShort.benchShort_$s$wbenchLoop
= \ (x_s4g5 :: ShortByteString)
(ww_s4g8 :: ghc-prim:GHC.Prim.Word64#)
(eta1_s4ga [OS=OneShot]
:: ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld) ->
case ww_s4g8 of wild_X1 {
__DEFAULT ->
case ghc-prim:GHC.Prim.seq#
@(Maybe Int)
@ghc-prim:GHC.Prim.RealWorld
(case x_s4g5
`cast` (Data.ByteString.Short.Internal.N:ShortByteString[0]
:: ShortByteString ~R# Data.Array.Byte.ByteArray)
of
{ Data.Array.Byte.ByteArray ba#_a44Q ->
case {__ffi_static_ccall_unsafe bytestring-0.11.3.1-inplace:sbs_elem_index :: ByteArray#
-> Word8#
-> Word64#
-> State# RealWorld
-> (# State# RealWorld,
Int64# #)}_a44T
ba#_a44Q
10##8
(ghc-prim:GHC.Prim.int64ToWord64#
(ghc-prim:GHC.Prim.intToInt64#
(ghc-prim:GHC.Prim.sizeofByteArray# ba#_a44Q)))
ghc-prim:GHC.Prim.realWorld#
of
{ (# ds2_a44X, ds3_a44Y #) ->
case ghc-prim:GHC.Prim.ltInt64# ds3_a44Y 0#64 of {
__DEFAULT ->
GHC.Maybe.Just
@Int
(ghc-prim:GHC.Types.I# (ghc-prim:GHC.Prim.int64ToInt# ds3_a44Y));
1# -> GHC.Maybe.Nothing @Int
}
}
})
eta1_s4ga
of
{ (# ipv_i41b, ipv1_i41c #) ->
BenchShort.benchShort_$s$wbenchLoop
x_s4g5 (ghc-prim:GHC.Prim.subWord64# wild_X1 1##64) ipv_i41b
};
0##64 -> eta1_s4ga
}
end Rec }
Rec {
-- RHS size: {terms: 30, types: 28, coercions: 0, joins: 0/0}
BenchShort.$wbenchLoop [InlPrag=[2], Occ=LoopBreaker]
:: (ShortByteString -> Maybe Int)
-> ShortByteString
-> ghc-prim:GHC.Prim.Word64#
-> ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld
-> ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld
[GblId, Arity=4, Str=<L><L><1L><L>, Unf=OtherCon []]
BenchShort.$wbenchLoop
= \ (f_s4g4 :: ShortByteString -> Maybe Int)
(x_s4g5 :: ShortByteString)
(ww_s4g8 :: ghc-prim:GHC.Prim.Word64#)
(eta1_s4ga [OS=OneShot]
:: ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld) ->
case ww_s4g8 of wild_X1 {
__DEFAULT ->
case ghc-prim:GHC.Prim.seq#
@(Maybe Int)
@ghc-prim:GHC.Prim.RealWorld
(case f_s4g4 x_s4g5 of wild1_i3Ph {
Nothing -> GHC.Maybe.Nothing @Int;
Just x1_i3Pi ->
case x1_i3Pi of { ghc-prim:GHC.Types.I# ipv_i3OX -> wild1_i3Ph }
})
eta1_s4ga
of
{ (# ipv_i41b, ipv1_i41c #) ->
BenchShort.$wbenchLoop
f_s4g4 x_s4g5 (ghc-prim:GHC.Prim.subWord64# wild_X1 1##64) ipv_i41b
};
0##64 -> eta1_s4ga
}
end Rec }
-- RHS size: {terms: 17, types: 16, coercions: 0, joins: 0/0}
BenchShort.benchShort10 [InlPrag=[2]]
:: (ShortByteString -> Maybe Int)
-> ShortByteString
-> Word64
-> ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld
-> (# ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld, () #)
[GblId[StrictWorker([~, ~, !])],
Arity=4,
Str=<L><L><1!P(1L)><L>,
Cpr=1(, 1),
Unf=Unf{Src=InlineStable, TopLvl=True, Value=True, ConLike=True,
WorkFree=True, Expandable=True,
Guidance=ALWAYS_IF(arity=4,unsat_ok=True,boring_ok=False)
Tmpl= \ (f_s4g4 [Occ=Once1] :: ShortByteString -> Maybe Int)
(x_s4g5 [Occ=Once1] :: ShortByteString)
(n2_s4g6 [Occ=Once1!] :: Word64)
(eta1_s4ga [Occ=Once1, OS=OneShot]
:: ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld) ->
case n2_s4g6 of { GHC.Word.W64# ww_s4g8 [Occ=Once1] ->
case BenchShort.$wbenchLoop f_s4g4 x_s4g5 ww_s4g8 eta1_s4ga
of ww1_s4gd [Occ=Once1]
{ __DEFAULT ->
(# ww1_s4gd, ghc-prim:GHC.Tuple.() #)
}
}}]
BenchShort.benchShort10
= \ (f_s4g4 :: ShortByteString -> Maybe Int)
(x_s4g5 :: ShortByteString)
(n2_s4g6 :: Word64)
(eta1_s4ga [OS=OneShot]
:: ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld) ->
case n2_s4g6 of { GHC.Word.W64# ww_s4g8 ->
case BenchShort.$wbenchLoop f_s4g4 x_s4g5 ww_s4g8 eta1_s4ga
of ww1_s4gd
{ __DEFAULT ->
(# ww1_s4gd, ghc-prim:GHC.Tuple.() #)
}
}
-- RHS size: {terms: 15, types: 12, coercions: 0, joins: 0/0}
BenchShort.benchShort41
:: Word64
-> ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld
-> (# ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld, () #)
[GblId,
Arity=2,
Str=<1!P(1L)><L>,
Cpr=1(, 1),
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= \ (eta2_i40X [Occ=Once1] :: Word64)
(eta3_i40Y [Occ=Once1, OS=OneShot]
:: ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld) ->
BenchShort.benchShort10
BenchShort.benchShort_eta3 absurdlong eta2_i40X eta3_i40Y}]
BenchShort.benchShort41
= \ (eta2_i40X :: Word64)
(eta3_i40Y [OS=OneShot]
:: ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld) ->
case eta2_i40X of { GHC.Word.W64# ww_s4g8 ->
case BenchShort.$wbenchLoop
BenchShort.benchShort_eta3 absurdlong ww_s4g8 eta3_i40Y
of ww1_s4gd
{ __DEFAULT ->
(# ww1_s4gd, ghc-prim:GHC.Tuple.() #)
}
}
-- RHS size: {terms: 4, types: 1, coercions: 9, joins: 0/0}
BenchShort.benchShort40
:: tasty-1.4.3-11a9f645de3563f4acd137dbd7b86bd64dc3ddbda96e45793d34b2df8917ea46:Test.Tasty.Core.TestTree
[GblId,
Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
WorkFree=True, Expandable=True, Guidance=IF_ARGS [] 10 10}]
BenchShort.benchShort40
= tasty-1.4.3-11a9f645de3563f4acd137dbd7b86bd64dc3ddbda96e45793d34b2df8917ea46:Test.Tasty.Core.SingleTest
@Benchmarkable
Test.Tasty.Bench.$fIsTestBenchmarkable
BenchShort.benchShort42
(BenchShort.benchShort41
`cast` (<Word64>_R
%<'Many>_N ->_R Sym (ghc-prim:GHC.Types.N:IO[0] <()>_R)
; Sym (Test.Tasty.Bench.N:Benchmarkable[0])
:: (Word64
-> ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld
-> (# ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld, () #))
~R# Benchmarkable))
-- RHS size: {terms: 14, types: 12, coercions: 0, joins: 0/0}
BenchShort.benchShort34
:: Word64
-> ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld
-> (# ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld, () #)
[GblId,
Arity=2,
Str=<1!P(1L)><L>,
Cpr=1(, 1),
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= \ (eta2_i40X [Occ=Once1] :: Word64)
(eta3_i40Y [Occ=Once1, OS=OneShot]
:: ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld) ->
BenchShort.benchShort10
BenchShort.benchShort_eta2 absurdlong eta2_i40X eta3_i40Y}]
BenchShort.benchShort34
= \ (eta2_i40X :: Word64)
(eta3_i40Y [OS=OneShot]
:: ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld) ->
case eta2_i40X of { GHC.Word.W64# ww_s4gV ->
case BenchShort.benchShort_$s$wbenchLoop
absurdlong ww_s4gV eta3_i40Y
of ww1_s4h0
{ __DEFAULT ->
(# ww1_s4h0, ghc-prim:GHC.Tuple.() #)
}
}
-- RHS size: {terms: 4, types: 1, coercions: 9, joins: 0/0}
BenchShort.benchShort33
:: tasty-1.4.3-11a9f645de3563f4acd137dbd7b86bd64dc3ddbda96e45793d34b2df8917ea46:Test.Tasty.Core.TestTree
[GblId,
Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
WorkFree=True, Expandable=True, Guidance=IF_ARGS [] 10 10}]
BenchShort.benchShort33
= tasty-1.4.3-11a9f645de3563f4acd137dbd7b86bd64dc3ddbda96e45793d34b2df8917ea46:Test.Tasty.Core.SingleTest
@Benchmarkable
Test.Tasty.Bench.$fIsTestBenchmarkable
BenchShort.benchShort35
(BenchShort.benchShort34
`cast` (<Word64>_R
%<'Many>_N ->_R Sym (ghc-prim:GHC.Types.N:IO[0] <()>_R)
; Sym (Test.Tasty.Bench.N:Benchmarkable[0])
:: (Word64
-> ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld
-> (# ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld, () #))
~R# Benchmarkable))
-- RHS size: {terms: 3, types: 2, coercions: 0, joins: 0/0}
BenchShort.benchShort32 :: [Benchmark]
[GblId,
Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
WorkFree=True, Expandable=True, Guidance=IF_ARGS [] 10 10}]
BenchShort.benchShort32
= ghc-prim:GHC.Types.:
@Benchmark
BenchShort.benchShort33
(ghc-prim:GHC.Types.[] @Benchmark)
-- RHS size: {terms: 14, types: 12, coercions: 0, joins: 0/0}
BenchShort.benchShort9
:: Word64
-> ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld
-> (# ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld, () #)
[GblId,
Arity=2,
Str=<1!P(1L)><L>,
Cpr=1(, 1),
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= \ (eta2_i40X [Occ=Once1] :: Word64)
(eta3_i40Y [Occ=Once1, OS=OneShot]
:: ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld) ->
BenchShort.benchShort10 find_index absurdlong eta2_i40X eta3_i40Y}]
BenchShort.benchShort9
= \ (eta2_i40X :: Word64)
(eta3_i40Y [OS=OneShot]
:: ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld) ->
case eta2_i40X of { GHC.Word.W64# ww_s4hY ->
case BenchShort.benchShort_$s$wbenchLoop1
absurdlong ww_s4hY eta3_i40Y
of ww1_s4i3
{ __DEFAULT ->
(# ww1_s4i3, ghc-prim:GHC.Tuple.() #)
}
}
-- RHS size: {terms: 4, types: 1, coercions: 9, joins: 0/0}
BenchShort.benchShort13
:: tasty-1.4.3-11a9f645de3563f4acd137dbd7b86bd64dc3ddbda96e45793d34b2df8917ea46:Test.Tasty.Core.TestTree
[GblId,
Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
WorkFree=True, Expandable=True, Guidance=IF_ARGS [] 10 10}]
BenchShort.benchShort13
= tasty-1.4.3-11a9f645de3563f4acd137dbd7b86bd64dc3ddbda96e45793d34b2df8917ea46:Test.Tasty.Core.SingleTest
@Benchmarkable
Test.Tasty.Bench.$fIsTestBenchmarkable
BenchShort.benchShort14
(BenchShort.benchShort9
`cast` (<Word64>_R
%<'Many>_N ->_R Sym (ghc-prim:GHC.Types.N:IO[0] <()>_R)
; Sym (Test.Tasty.Bench.N:Benchmarkable[0])
:: (Word64
-> ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld
-> (# ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld, () #))
~R# Benchmarkable))
-- RHS size: {terms: 4, types: 1, coercions: 9, joins: 0/0}
BenchShort.benchShort8
:: tasty-1.4.3-11a9f645de3563f4acd137dbd7b86bd64dc3ddbda96e45793d34b2df8917ea46:Test.Tasty.Core.TestTree
[GblId,
Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
WorkFree=True, Expandable=True, Guidance=IF_ARGS [] 10 10}]
BenchShort.benchShort8
= tasty-1.4.3-11a9f645de3563f4acd137dbd7b86bd64dc3ddbda96e45793d34b2df8917ea46:Test.Tasty.Core.SingleTest
@Benchmarkable
Test.Tasty.Bench.$fIsTestBenchmarkable
BenchShort.benchShort11
(BenchShort.benchShort9
`cast` (<Word64>_R
%<'Many>_N ->_R Sym (ghc-prim:GHC.Types.N:IO[0] <()>_R)
; Sym (Test.Tasty.Bench.N:Benchmarkable[0])
:: (Word64
-> ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld
-> (# ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld, () #))
~R# Benchmarkable))
-- RHS size: {terms: 3, types: 2, coercions: 0, joins: 0/0}
BenchShort.benchShort7 :: [Benchmark]
[GblId,
Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
WorkFree=True, Expandable=True, Guidance=IF_ARGS [] 10 10}]
BenchShort.benchShort7
= ghc-prim:GHC.Types.:
@Benchmark
BenchShort.benchShort8
(ghc-prim:GHC.Types.[] @Benchmark)
-- RHS size: {terms: 3, types: 1, coercions: 0, joins: 0/0}
BenchShort.benchShort6 :: [Benchmark]
[GblId,
Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
WorkFree=True, Expandable=True, Guidance=IF_ARGS [] 10 10}]
BenchShort.benchShort6
= ghc-prim:GHC.Types.:
@Benchmark BenchShort.benchShort13 BenchShort.benchShort7
-- RHS size: {terms: 4, types: 1, coercions: 9, joins: 0/0}
BenchShort.benchShort37
:: tasty-1.4.3-11a9f645de3563f4acd137dbd7b86bd64dc3ddbda96e45793d34b2df8917ea46:Test.Tasty.Core.TestTree
[GblId,
Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
WorkFree=True, Expandable=True, Guidance=IF_ARGS [] 10 10}]
BenchShort.benchShort37
= tasty-1.4.3-11a9f645de3563f4acd137dbd7b86bd64dc3ddbda96e45793d34b2df8917ea46:Test.Tasty.Core.SingleTest
@Benchmarkable
Test.Tasty.Bench.$fIsTestBenchmarkable
BenchShort.benchShort38
(BenchShort.benchShort9
`cast` (<Word64>_R
%<'Many>_N ->_R Sym (ghc-prim:GHC.Types.N:IO[0] <()>_R)
; Sym (Test.Tasty.Bench.N:Benchmarkable[0])
:: (Word64
-> ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld
-> (# ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld, () #))
~R# Benchmarkable))
-- RHS size: {terms: 3, types: 1, coercions: 0, joins: 0/0}
BenchShort.benchShort31 :: [Benchmark]
[GblId,
Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
WorkFree=True, Expandable=True, Guidance=IF_ARGS [] 10 10}]
BenchShort.benchShort31
= ghc-prim:GHC.Types.:
@Benchmark BenchShort.benchShort37 BenchShort.benchShort32
-- RHS size: {terms: 3, types: 1, coercions: 0, joins: 0/0}
BenchShort.benchShort30 :: [Benchmark]
[GblId,
Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
WorkFree=True, Expandable=True, Guidance=IF_ARGS [] 10 10}]
BenchShort.benchShort30
= ghc-prim:GHC.Types.:
@Benchmark BenchShort.benchShort40 BenchShort.benchShort31
-- RHS size: {terms: 3, types: 0, coercions: 0, joins: 0/0}
BenchShort.benchShort29
:: tasty-1.4.3-11a9f645de3563f4acd137dbd7b86bd64dc3ddbda96e45793d34b2df8917ea46:Test.Tasty.Core.TestTree
[GblId,
Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
WorkFree=True, Expandable=True, Guidance=IF_ARGS [] 10 10}]
BenchShort.benchShort29
= tasty-1.4.3-11a9f645de3563f4acd137dbd7b86bd64dc3ddbda96e45793d34b2df8917ea46:Test.Tasty.Core.TestGroup
BenchShort.benchShort44 BenchShort.benchShort30
Rec {
-- RHS size: {terms: 11, types: 9, coercions: 0, joins: 0/0}
$wgo_r4ms :: [Int] -> (# #)
[GblId[StrictWorker([!])], Arity=1, Str=<1L>, Unf=OtherCon []]
$wgo_r4ms
= \ (ds_s4fC :: [Int]) ->
case ds_s4fC of {
[] -> ghc-prim:GHC.Prim.(##);
: x_i3P5 xs_i3P6 ->
case x_i3P5 of { ghc-prim:GHC.Types.I# ipv_i3OX ->
$wgo_r4ms xs_i3P6
}
}
end Rec }
Rec {
-- RHS size: {terms: 26, types: 22, coercions: 0, joins: 0/1}
BenchShort.benchShort_$s$wbenchLoop3 [Occ=LoopBreaker]
:: ShortByteString
-> ghc-prim:GHC.Prim.Word64#
-> ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld
-> ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld
[GblId, Arity=3, Str=<L><1L><L>, Unf=OtherCon []]
BenchShort.benchShort_$s$wbenchLoop3
= \ (x_s4hh :: ShortByteString)
(ww_s4hk :: ghc-prim:GHC.Prim.Word64#)
(eta1_s4hm [OS=OneShot]
:: ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld) ->
case ww_s4hk of wild_X1 {
__DEFAULT ->
case ghc-prim:GHC.Prim.seq#
@[Int]
@ghc-prim:GHC.Prim.RealWorld
(let {
x1_s45F [Dmd=SL] :: [Int]
[LclId]
x1_s45F = BenchShort.benchShort_eta1 x_s4hh } in
case $wgo_r4ms x1_s45F of { (# #) -> x1_s45F })
eta1_s4hm
of
{ (# ipv_i41b, ipv1_i41c #) ->
BenchShort.benchShort_$s$wbenchLoop3
x_s4hh (ghc-prim:GHC.Prim.subWord64# wild_X1 1##64) ipv_i41b
};
0##64 -> eta1_s4hm
}
end Rec }
Rec {
-- RHS size: {terms: 28, types: 25, coercions: 0, joins: 0/1}
BenchShort.$wbenchLoop2 [InlPrag=[2], Occ=LoopBreaker]
:: (ShortByteString -> [Int])
-> ShortByteString
-> ghc-prim:GHC.Prim.Word64#
-> ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld
-> ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld
[GblId, Arity=4, Str=<L><L><1L><L>, Unf=OtherCon []]
BenchShort.$wbenchLoop2
= \ (f_s4hg :: ShortByteString -> [Int])
(x_s4hh :: ShortByteString)
(ww_s4hk :: ghc-prim:GHC.Prim.Word64#)
(eta1_s4hm [OS=OneShot]
:: ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld) ->
case ww_s4hk of wild_X1 {
__DEFAULT ->
case ghc-prim:GHC.Prim.seq#
@[Int]
@ghc-prim:GHC.Prim.RealWorld
(let {
x1_s45F [Dmd=SL] :: [Int]
[LclId]
x1_s45F = f_s4hg x_s4hh } in
case $wgo_r4ms x1_s45F of { (# #) -> x1_s45F })
eta1_s4hm
of
{ (# ipv_i41b, ipv1_i41c #) ->
BenchShort.$wbenchLoop2
f_s4hg x_s4hh (ghc-prim:GHC.Prim.subWord64# wild_X1 1##64) ipv_i41b
};
0##64 -> eta1_s4hm
}
end Rec }
-- RHS size: {terms: 17, types: 16, coercions: 0, joins: 0/0}
BenchShort.benchShort24 [InlPrag=[2]]
:: (ShortByteString -> [Int])
-> ShortByteString
-> Word64
-> ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld
-> (# ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld, () #)
[GblId[StrictWorker([~, ~, !])],
Arity=4,
Str=<L><L><1!P(1L)><L>,
Cpr=1(, 1),
Unf=Unf{Src=InlineStable, TopLvl=True, Value=True, ConLike=True,
WorkFree=True, Expandable=True,
Guidance=ALWAYS_IF(arity=4,unsat_ok=True,boring_ok=False)
Tmpl= \ (f_s4hg [Occ=Once1] :: ShortByteString -> [Int])
(x_s4hh [Occ=Once1] :: ShortByteString)
(n2_s4hi [Occ=Once1!] :: Word64)
(eta1_s4hm [Occ=Once1, OS=OneShot]
:: ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld) ->
case n2_s4hi of { GHC.Word.W64# ww_s4hk [Occ=Once1] ->
case BenchShort.$wbenchLoop2 f_s4hg x_s4hh ww_s4hk eta1_s4hm
of ww1_s4hp [Occ=Once1]
{ __DEFAULT ->
(# ww1_s4hp, ghc-prim:GHC.Tuple.() #)
}
}}]
BenchShort.benchShort24
= \ (f_s4hg :: ShortByteString -> [Int])
(x_s4hh :: ShortByteString)
(n2_s4hi :: Word64)
(eta1_s4hm [OS=OneShot]
:: ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld) ->
case n2_s4hi of { GHC.Word.W64# ww_s4hk ->
case BenchShort.$wbenchLoop2 f_s4hg x_s4hh ww_s4hk eta1_s4hm
of ww1_s4hp
{ __DEFAULT ->
(# ww1_s4hp, ghc-prim:GHC.Tuple.() #)
}
}
-- RHS size: {terms: 14, types: 12, coercions: 0, joins: 0/0}
BenchShort.benchShort23
:: Word64
-> ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld
-> (# ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld, () #)
[GblId,
Arity=2,
Str=<1!P(1L)><L>,
Cpr=1(, 1),
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= \ (eta2_i40X [Occ=Once1] :: Word64)
(eta3_i40Y [Occ=Once1, OS=OneShot]
:: ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld) ->
BenchShort.benchShort24
BenchShort.benchShort_eta1 absurdlong eta2_i40X eta3_i40Y}]
BenchShort.benchShort23
= \ (eta2_i40X :: Word64)
(eta3_i40Y [OS=OneShot]
:: ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld) ->
case eta2_i40X of { GHC.Word.W64# ww_s4hk ->
case BenchShort.benchShort_$s$wbenchLoop3
absurdlong ww_s4hk eta3_i40Y
of ww1_s4hp
{ __DEFAULT ->
(# ww1_s4hp, ghc-prim:GHC.Tuple.() #)
}
}
-- RHS size: {terms: 4, types: 1, coercions: 9, joins: 0/0}
BenchShort.benchShort22
:: tasty-1.4.3-11a9f645de3563f4acd137dbd7b86bd64dc3ddbda96e45793d34b2df8917ea46:Test.Tasty.Core.TestTree
[GblId,
Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
WorkFree=True, Expandable=True, Guidance=IF_ARGS [] 10 10}]
BenchShort.benchShort22
= tasty-1.4.3-11a9f645de3563f4acd137dbd7b86bd64dc3ddbda96e45793d34b2df8917ea46:Test.Tasty.Core.SingleTest
@Benchmarkable
Test.Tasty.Bench.$fIsTestBenchmarkable
BenchShort.benchShort25
(BenchShort.benchShort23
`cast` (<Word64>_R
%<'Many>_N ->_R Sym (ghc-prim:GHC.Types.N:IO[0] <()>_R)
; Sym (Test.Tasty.Bench.N:Benchmarkable[0])
:: (Word64
-> ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld
-> (# ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld, () #))
~R# Benchmarkable))
Rec {
-- RHS size: {terms: 26, types: 22, coercions: 0, joins: 0/1}
BenchShort.benchShort_$s$wbenchLoop2 [Occ=LoopBreaker]
:: ShortByteString
-> ghc-prim:GHC.Prim.Word64#
-> ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld
-> ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld
[GblId, Arity=3, Str=<L><1L><L>, Unf=OtherCon []]
BenchShort.benchShort_$s$wbenchLoop2
= \ (x_s4hG :: ShortByteString)
(ww_s4hJ :: ghc-prim:GHC.Prim.Word64#)
(eta1_s4hL [OS=OneShot]
:: ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld) ->
case ww_s4hJ of wild_X1 {
__DEFAULT ->
case ghc-prim:GHC.Prim.seq#
@[Int]
@ghc-prim:GHC.Prim.RealWorld
(let {
x1_s45x [Dmd=SL] :: [Int]
[LclId]
x1_s45x = BenchShort.benchShort_eta x_s4hG } in
case $wgo_r4ms x1_s45x of { (# #) -> x1_s45x })
eta1_s4hL
of
{ (# ipv_i41b, ipv1_i41c #) ->
BenchShort.benchShort_$s$wbenchLoop2
x_s4hG (ghc-prim:GHC.Prim.subWord64# wild_X1 1##64) ipv_i41b
};
0##64 -> eta1_s4hL
}
end Rec }
Rec {
-- RHS size: {terms: 28, types: 25, coercions: 0, joins: 0/1}
BenchShort.$wbenchLoop1 [InlPrag=[2], Occ=LoopBreaker]
:: (ShortByteString -> [Int])
-> ShortByteString
-> ghc-prim:GHC.Prim.Word64#
-> ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld
-> ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld
[GblId, Arity=4, Str=<L><L><1L><L>, Unf=OtherCon []]
BenchShort.$wbenchLoop1
= \ (f_s4hF :: ShortByteString -> [Int])
(x_s4hG :: ShortByteString)
(ww_s4hJ :: ghc-prim:GHC.Prim.Word64#)
(eta1_s4hL [OS=OneShot]
:: ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld) ->
case ww_s4hJ of wild_X1 {
__DEFAULT ->
case ghc-prim:GHC.Prim.seq#
@[Int]
@ghc-prim:GHC.Prim.RealWorld
(let {
x1_s45x [Dmd=SL] :: [Int]
[LclId]
x1_s45x = f_s4hF x_s4hG } in
case $wgo_r4ms x1_s45x of { (# #) -> x1_s45x })
eta1_s4hL
of
{ (# ipv_i41b, ipv1_i41c #) ->
BenchShort.$wbenchLoop1
f_s4hF x_s4hG (ghc-prim:GHC.Prim.subWord64# wild_X1 1##64) ipv_i41b
};
0##64 -> eta1_s4hL
}
end Rec }
-- RHS size: {terms: 17, types: 16, coercions: 0, joins: 0/0}
BenchShort.benchShort19 [InlPrag=[2]]
:: (ShortByteString -> [Int])
-> ShortByteString
-> Word64
-> ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld
-> (# ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld, () #)
[GblId[StrictWorker([~, ~, !])],
Arity=4,
Str=<L><L><1!P(1L)><L>,
Cpr=1(, 1),
Unf=Unf{Src=InlineStable, TopLvl=True, Value=True, ConLike=True,
WorkFree=True, Expandable=True,
Guidance=ALWAYS_IF(arity=4,unsat_ok=True,boring_ok=False)
Tmpl= \ (f_s4hF [Occ=Once1] :: ShortByteString -> [Int])
(x_s4hG [Occ=Once1] :: ShortByteString)
(n2_s4hH [Occ=Once1!] :: Word64)
(eta1_s4hL [Occ=Once1, OS=OneShot]
:: ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld) ->
case n2_s4hH of { GHC.Word.W64# ww_s4hJ [Occ=Once1] ->
case BenchShort.$wbenchLoop1 f_s4hF x_s4hG ww_s4hJ eta1_s4hL
of ww1_s4hO [Occ=Once1]
{ __DEFAULT ->
(# ww1_s4hO, ghc-prim:GHC.Tuple.() #)
}
}}]
BenchShort.benchShort19
= \ (f_s4hF :: ShortByteString -> [Int])
(x_s4hG :: ShortByteString)
(n2_s4hH :: Word64)
(eta1_s4hL [OS=OneShot]
:: ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld) ->
case n2_s4hH of { GHC.Word.W64# ww_s4hJ ->
case BenchShort.$wbenchLoop1 f_s4hF x_s4hG ww_s4hJ eta1_s4hL
of ww1_s4hO
{ __DEFAULT ->
(# ww1_s4hO, ghc-prim:GHC.Tuple.() #)
}
}
-- RHS size: {terms: 14, types: 12, coercions: 0, joins: 0/0}
BenchShort.benchShort17
:: Word64
-> ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld
-> (# ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld, () #)
[GblId,
Arity=2,
Str=<1!P(1L)><L>,
Cpr=1(, 1),
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= \ (eta2_i40X [Occ=Once1] :: Word64)
(eta3_i40Y [Occ=Once1, OS=OneShot]
:: ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld) ->
BenchShort.benchShort19
BenchShort.benchShort_eta absurdlong eta2_i40X eta3_i40Y}]
BenchShort.benchShort17
= \ (eta2_i40X :: Word64)
(eta3_i40Y [OS=OneShot]
:: ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld) ->
case eta2_i40X of { GHC.Word.W64# ww_s4hJ ->
case BenchShort.benchShort_$s$wbenchLoop2
absurdlong ww_s4hJ eta3_i40Y
of ww1_s4hO
{ __DEFAULT ->
(# ww1_s4hO, ghc-prim:GHC.Tuple.() #)
}
}
-- RHS size: {terms: 4, types: 1, coercions: 9, joins: 0/0}
BenchShort.benchShort16
:: tasty-1.4.3-11a9f645de3563f4acd137dbd7b86bd64dc3ddbda96e45793d34b2df8917ea46:Test.Tasty.Core.TestTree
[GblId,
Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
WorkFree=True, Expandable=True, Guidance=IF_ARGS [] 10 10}]
BenchShort.benchShort16
= tasty-1.4.3-11a9f645de3563f4acd137dbd7b86bd64dc3ddbda96e45793d34b2df8917ea46:Test.Tasty.Core.SingleTest
@Benchmarkable
Test.Tasty.Bench.$fIsTestBenchmarkable
BenchShort.benchShort20
(BenchShort.benchShort17
`cast` (<Word64>_R
%<'Many>_N ->_R Sym (ghc-prim:GHC.Types.N:IO[0] <()>_R)
; Sym (Test.Tasty.Bench.N:Benchmarkable[0])
:: (Word64
-> ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld
-> (# ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld, () #))
~R# Benchmarkable))
-- RHS size: {terms: 3, types: 1, coercions: 0, joins: 0/0}
BenchShort.benchShort5 :: [Benchmark]
[GblId,
Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
WorkFree=True, Expandable=True, Guidance=IF_ARGS [] 10 10}]
BenchShort.benchShort5
= ghc-prim:GHC.Types.:
@Benchmark BenchShort.benchShort16 BenchShort.benchShort6
-- RHS size: {terms: 3, types: 1, coercions: 0, joins: 0/0}
BenchShort.benchShort4 :: [Benchmark]
[GblId,
Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
WorkFree=True, Expandable=True, Guidance=IF_ARGS [] 10 10}]
BenchShort.benchShort4
= ghc-prim:GHC.Types.:
@Benchmark BenchShort.benchShort22 BenchShort.benchShort5
-- RHS size: {terms: 3, types: 0, coercions: 0, joins: 0/0}
BenchShort.benchShort3
:: tasty-1.4.3-11a9f645de3563f4acd137dbd7b86bd64dc3ddbda96e45793d34b2df8917ea46:Test.Tasty.Core.TestTree
[GblId,
Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
WorkFree=True, Expandable=True, Guidance=IF_ARGS [] 10 10}]
BenchShort.benchShort3
= tasty-1.4.3-11a9f645de3563f4acd137dbd7b86bd64dc3ddbda96e45793d34b2df8917ea46:Test.Tasty.Core.TestGroup
BenchShort.benchShort27 BenchShort.benchShort4
-- RHS size: {terms: 3, types: 2, coercions: 0, joins: 0/0}
BenchShort.benchShort2 :: [Benchmark]
[GblId,
Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
WorkFree=True, Expandable=True, Guidance=IF_ARGS [] 10 10}]
BenchShort.benchShort2
= ghc-prim:GHC.Types.:
@Benchmark
BenchShort.benchShort3
(ghc-prim:GHC.Types.[] @Benchmark)
-- RHS size: {terms: 3, types: 1, coercions: 0, joins: 0/0}
BenchShort.benchShort1 :: [Benchmark]
[GblId,
Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
WorkFree=True, Expandable=True, Guidance=IF_ARGS [] 10 10}]
BenchShort.benchShort1
= ghc-prim:GHC.Types.:
@Benchmark BenchShort.benchShort29 BenchShort.benchShort2
-- RHS size: {terms: 3, types: 0, coercions: 0, joins: 0/0}
benchShort :: Benchmark
[GblId,
Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
WorkFree=True, Expandable=True, Guidance=IF_ARGS [] 10 10}]
benchShort
= tasty-1.4.3-11a9f645de3563f4acd137dbd7b86bd64dc3ddbda96e45793d34b2df8917ea46:Test.Tasty.Core.TestGroup
BenchShort.benchShort46 BenchShort.benchShort1
-- RHS size: {terms: 1, types: 0, coercions: 0, joins: 0/0}
BenchShort.$trModule2 :: ghc-prim:GHC.Prim.Addr#
[GblId,
Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
WorkFree=True, Expandable=True, Guidance=IF_ARGS [] 40 0}]
BenchShort.$trModule2 = "BenchShort"#
-- RHS size: {terms: 2, types: 0, coercions: 0, joins: 0/0}
BenchShort.$trModule1 :: ghc-prim:GHC.Types.TrName
[GblId,
Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
WorkFree=True, Expandable=True, Guidance=IF_ARGS [] 10 10}]
BenchShort.$trModule1
= ghc-prim:GHC.Types.TrNameS BenchShort.$trModule2
-- RHS size: {terms: 1, types: 0, coercions: 0, joins: 0/0}
BenchShort.$trModule4 :: ghc-prim:GHC.Prim.Addr#
[GblId,
Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
WorkFree=True, Expandable=True, Guidance=IF_ARGS [] 20 0}]
BenchShort.$trModule4 = "main"#
-- RHS size: {terms: 2, types: 0, coercions: 0, joins: 0/0}
BenchShort.$trModule3 :: ghc-prim:GHC.Types.TrName
[GblId,
Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
WorkFree=True, Expandable=True, Guidance=IF_ARGS [] 10 10}]
BenchShort.$trModule3
= ghc-prim:GHC.Types.TrNameS BenchShort.$trModule4
-- RHS size: {terms: 3, types: 0, coercions: 0, joins: 0/0}
BenchShort.$trModule :: ghc-prim:GHC.Types.Module
[GblId,
Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
WorkFree=True, Expandable=True, Guidance=IF_ARGS [] 10 10}]
BenchShort.$trModule
= ghc-prim:GHC.Types.Module
BenchShort.$trModule3 BenchShort.$trModule1
------ Local rules for imported ids --------
"SC:$wbenchLoop0" [2]
forall.
BenchShort.$wbenchLoop find_index
= BenchShort.benchShort_$s$wbenchLoop1
"SC:$wbenchLoop1" [2]
forall.
BenchShort.$wbenchLoop BenchShort.benchShort_eta2
= BenchShort.benchShort_$s$wbenchLoop
"SC:$wbenchLoop0" [2]
forall.
BenchShort.$wbenchLoop2 BenchShort.benchShort_eta1
= BenchShort.benchShort_$s$wbenchLoop3
"SC:$wbenchLoop0" [2]
forall.
BenchShort.$wbenchLoop1 BenchShort.benchShort_eta
= BenchShort.benchShort_$s$wbenchLoop2
Raw
BenchShort.dump-simpl-9.6
==================== Tidy Core ====================
2023-02-07 11:26:52.430858373 UTC
Result size of Tidy Core
= {terms: 1,538, types: 1,409, coercions: 74, joins: 4/48}
-- RHS size: {terms: 1, types: 0, coercions: 0, joins: 0/0}
BenchShort.benchShort12 :: ghc-prim:GHC.Prim.Addr#
[GblId,
Unf=Unf{Src=<vanilla>, TopLvl=True,
Value=True, ConLike=True, WorkFree=True, Expandable=True,
Guidance=IF_ARGS [] 70 0}]
BenchShort.benchShort12 = "FindIndex/non-inlined"#
-- RHS size: {terms: 2, types: 0, coercions: 0, joins: 0/0}
BenchShort.benchShort11 :: [Char]
[GblId,
Unf=Unf{Src=<vanilla>, TopLvl=True,
Value=False, ConLike=True, WorkFree=False, Expandable=True,
Guidance=IF_ARGS [] 20 0}]
BenchShort.benchShort11
= ghc-prim:GHC.CString.unpackCString# BenchShort.benchShort12
-- RHS size: {terms: 1, types: 0, coercions: 0, joins: 0/0}
BenchShort.benchShort15 :: ghc-prim:GHC.Prim.Addr#
[GblId,
Unf=Unf{Src=<vanilla>, TopLvl=True,
Value=True, ConLike=True, WorkFree=True, Expandable=True,
Guidance=IF_ARGS [] 60 0}]
BenchShort.benchShort15 = "FindIndex/inlined"#
-- RHS size: {terms: 2, types: 0, coercions: 0, joins: 0/0}
BenchShort.benchShort14 :: [Char]
[GblId,
Unf=Unf{Src=<vanilla>, TopLvl=True,
Value=False, ConLike=True, WorkFree=False, Expandable=True,
Guidance=IF_ARGS [] 20 0}]
BenchShort.benchShort14
= ghc-prim:GHC.CString.unpackCString# BenchShort.benchShort15
-- RHS size: {terms: 1, types: 0, coercions: 0, joins: 0/0}
BenchShort.benchShort21 :: ghc-prim:GHC.Prim.Addr#
[GblId,
Unf=Unf{Src=<vanilla>, TopLvl=True,
Value=True, ConLike=True, WorkFree=True, Expandable=True,
Guidance=IF_ARGS [] 70 0}]
BenchShort.benchShort21 = "FindIndices/non-inlined"#
-- RHS size: {terms: 2, types: 0, coercions: 0, joins: 0/0}
BenchShort.benchShort20 :: [Char]
[GblId,
Unf=Unf{Src=<vanilla>, TopLvl=True,
Value=False, ConLike=True, WorkFree=False, Expandable=True,
Guidance=IF_ARGS [] 20 0}]
BenchShort.benchShort20
= ghc-prim:GHC.CString.unpackCString# BenchShort.benchShort21
-- RHS size: {terms: 1, types: 0, coercions: 0, joins: 0/0}
BenchShort.benchShort26 :: ghc-prim:GHC.Prim.Addr#
[GblId,
Unf=Unf{Src=<vanilla>, TopLvl=True,
Value=True, ConLike=True, WorkFree=True, Expandable=True,
Guidance=IF_ARGS [] 60 0}]
BenchShort.benchShort26 = "FindIndices/inlined"#
-- RHS size: {terms: 2, types: 0, coercions: 0, joins: 0/0}
BenchShort.benchShort25 :: [Char]
[GblId,
Unf=Unf{Src=<vanilla>, TopLvl=True,
Value=False, ConLike=True, WorkFree=False, Expandable=True,
Guidance=IF_ARGS [] 20 0}]
BenchShort.benchShort25
= ghc-prim:GHC.CString.unpackCString# BenchShort.benchShort26
-- RHS size: {terms: 1, types: 0, coercions: 0, joins: 0/0}
BenchShort.benchShort28 :: ghc-prim:GHC.Prim.Addr#
[GblId,
Unf=Unf{Src=<vanilla>, TopLvl=True,
Value=True, ConLike=True, WorkFree=True, Expandable=True,
Guidance=IF_ARGS [] 110 0}]
BenchShort.benchShort28
= "ShortByteString index equality inlining"#
-- RHS size: {terms: 2, types: 0, coercions: 0, joins: 0/0}
BenchShort.benchShort27 :: [Char]
[GblId,
Unf=Unf{Src=<vanilla>, TopLvl=True,
Value=False, ConLike=True, WorkFree=False, Expandable=True,
Guidance=IF_ARGS [] 20 0}]
BenchShort.benchShort27
= ghc-prim:GHC.CString.unpackCString# BenchShort.benchShort28
-- RHS size: {terms: 1, types: 0, coercions: 0, joins: 0/0}
BenchShort.benchShort36 :: ghc-prim:GHC.Prim.Addr#
[GblId,
Unf=Unf{Src=<vanilla>, TopLvl=True,
Value=True, ConLike=True, WorkFree=True, Expandable=True,
Guidance=IF_ARGS [] 40 0}]
BenchShort.benchShort36 = "ElemIndex"#
-- RHS size: {terms: 2, types: 0, coercions: 0, joins: 0/0}
BenchShort.benchShort35 :: [Char]
[GblId,
Unf=Unf{Src=<vanilla>, TopLvl=True,
Value=False, ConLike=True, WorkFree=False, Expandable=True,
Guidance=IF_ARGS [] 20 0}]
BenchShort.benchShort35
= ghc-prim:GHC.CString.unpackCString# BenchShort.benchShort36
-- RHS size: {terms: 1, types: 0, coercions: 0, joins: 0/0}
BenchShort.benchShort40 :: ghc-prim:GHC.Prim.Addr#
[GblId,
Unf=Unf{Src=<vanilla>, TopLvl=True,
Value=True, ConLike=True, WorkFree=True, Expandable=True,
Guidance=IF_ARGS [] 40 0}]
BenchShort.benchShort40 = "FindIndex"#
-- RHS size: {terms: 2, types: 0, coercions: 0, joins: 0/0}
BenchShort.benchShort39 :: [Char]
[GblId,
Unf=Unf{Src=<vanilla>, TopLvl=True,
Value=False, ConLike=True, WorkFree=False, Expandable=True,
Guidance=IF_ARGS [] 20 0}]
BenchShort.benchShort39
= ghc-prim:GHC.CString.unpackCString# BenchShort.benchShort40
-- RHS size: {terms: 1, types: 0, coercions: 0, joins: 0/0}
BenchShort.benchShort44 :: ghc-prim:GHC.Prim.Addr#
[GblId,
Unf=Unf{Src=<vanilla>, TopLvl=True,
Value=True, ConLike=True, WorkFree=True, Expandable=True,
Guidance=IF_ARGS [] 40 0}]
BenchShort.benchShort44 = "FindIndices"#
-- RHS size: {terms: 2, types: 0, coercions: 0, joins: 0/0}
BenchShort.benchShort43 :: [Char]
[GblId,
Unf=Unf{Src=<vanilla>, TopLvl=True,
Value=False, ConLike=True, WorkFree=False, Expandable=True,
Guidance=IF_ARGS [] 20 0}]
BenchShort.benchShort43
= ghc-prim:GHC.CString.unpackCString# BenchShort.benchShort44
-- RHS size: {terms: 1, types: 0, coercions: 0, joins: 0/0}
BenchShort.benchShort46 :: ghc-prim:GHC.Prim.Addr#
[GblId,
Unf=Unf{Src=<vanilla>, TopLvl=True,
Value=True, ConLike=True, WorkFree=True, Expandable=True,
Guidance=IF_ARGS [] 100 0}]
BenchShort.benchShort46 = "ShortByteString strict first index"#
-- RHS size: {terms: 2, types: 0, coercions: 0, joins: 0/0}
BenchShort.benchShort45 :: [Char]
[GblId,
Unf=Unf{Src=<vanilla>, TopLvl=True,
Value=False, ConLike=True, WorkFree=False, Expandable=True,
Guidance=IF_ARGS [] 20 0}]
BenchShort.benchShort45
= ghc-prim:GHC.CString.unpackCString# BenchShort.benchShort46
-- RHS size: {terms: 2, types: 0, coercions: 0, joins: 0/0}
BenchShort.benchShort18 :: Word8
[GblId,
Unf=Unf{Src=<vanilla>, TopLvl=True,
Value=True, ConLike=True, WorkFree=True, Expandable=True,
Guidance=IF_ARGS [] 10 10}]
BenchShort.benchShort18 = GHC.Word.W8# 10#Word8
-- RHS size: {terms: 36, types: 11, coercions: 0, joins: 0/2}
BenchShort.$weta1 [InlPrag=[2]]
:: ghc-prim:GHC.Prim.ByteArray# -> [Int]
[GblId,
Arity=1,
Str=<L>,
Unf=Unf{Src=<vanilla>, TopLvl=True,
Value=True, ConLike=True, WorkFree=True, Expandable=True,
Guidance=IF_ARGS [0] 146 0}]
BenchShort.$weta1
= \ (ww_s4B5 :: ghc-prim:GHC.Prim.ByteArray#) ->
let {
l_a4xv :: ghc-prim:GHC.Prim.Int#
[LclId]
l_a4xv = ghc-prim:GHC.Prim.sizeofByteArray# ww_s4B5 } in
letrec {
$sgo_a4xw [Occ=LoopBreaker, Dmd=SC(S,L)]
:: ghc-prim:GHC.Prim.Int# -> [Int]
[LclId, Arity=1, Str=<L>, Unf=OtherCon []]
$sgo_a4xw
= \ (sc_a4xx :: ghc-prim:GHC.Prim.Int#) ->
case ghc-prim:GHC.Prim.>=# sc_a4xx l_a4xv of {
__DEFAULT ->
case ghc-prim:GHC.Prim.indexWord8Array# ww_s4B5 sc_a4xx of ds_a4xz
{ __DEFAULT ->
case ghc-prim:GHC.Prim.word8ToWord# ds_a4xz of {
__DEFAULT -> $sgo_a4xw (ghc-prim:GHC.Prim.+# sc_a4xx 1#);
10## ->
ghc-prim:GHC.Types.:
@Int
(ghc-prim:GHC.Types.I# sc_a4xx)
($sgo_a4xw (ghc-prim:GHC.Prim.+# sc_a4xx 1#))
}
};
1# -> ghc-prim:GHC.Types.[] @Int
}; } in
$sgo_a4xw 0#
-- RHS size: {terms: 6, types: 3, coercions: 1, joins: 0/0}
BenchShort.benchShort_eta1 [InlPrag=[2]]
:: ShortByteString -> [Int]
[GblId,
Arity=1,
Str=<1!P(L)>,
Unf=Unf{Src=StableSystem, TopLvl=True,
Value=True, ConLike=True, WorkFree=True, Expandable=True,
Guidance=ALWAYS_IF(arity=1,unsat_ok=True,boring_ok=False)
Tmpl= \ (sbs_s4B3 [Occ=Once1!] :: ShortByteString) ->
case sbs_s4B3
`cast` (Data.ByteString.Short.Internal.N:ShortByteString[0]
:: ShortByteString ~R# Data.Array.Byte.ByteArray)
of
{ Data.Array.Byte.ByteArray ww_s4B5 [Occ=Once1] ->
BenchShort.$weta1 ww_s4B5
}}]
BenchShort.benchShort_eta1
= \ (sbs_s4B3 :: ShortByteString) ->
case sbs_s4B3
`cast` (Data.ByteString.Short.Internal.N:ShortByteString[0]
:: ShortByteString ~R# Data.Array.Byte.ByteArray)
of
{ Data.Array.Byte.ByteArray ww_s4B5 ->
BenchShort.$weta1 ww_s4B5
}
-- RHS size: {terms: 25, types: 15, coercions: 1, joins: 0/0}
BenchShort.benchShort_eta2 :: ShortByteString -> Maybe Int
[GblId,
Arity=1,
Str=<1!P(L)>,
Unf=Unf{Src=StableSystem, TopLvl=True,
Value=True, ConLike=True, WorkFree=True, Expandable=True,
Guidance=ALWAYS_IF(arity=1,unsat_ok=True,boring_ok=False)
Tmpl= \ (sbs_a4oB [Occ=Once1!] :: ShortByteString) ->
case sbs_a4oB
`cast` (Data.ByteString.Short.Internal.N:ShortByteString[0]
:: ShortByteString ~R# Data.Array.Byte.ByteArray)
of
{ Data.Array.Byte.ByteArray ba#_a4oD ->
case {__ffi_static_ccall_unsafe bytestring-0.11.3.1-inplace:sbs_elem_index :: ByteArray#
-> Word8#
-> Word64#
-> State# RealWorld
-> (# State# RealWorld,
Int64# #)}_a4oG
ba#_a4oD
10#Word8
(ghc-prim:GHC.Prim.int64ToWord64#
(ghc-prim:GHC.Prim.intToInt64#
(ghc-prim:GHC.Prim.sizeofByteArray# ba#_a4oD)))
ghc-prim:GHC.Prim.realWorld#
of
{ (# _ [Occ=Dead], ds3_a4oL #) ->
case ghc-prim:GHC.Prim.ltInt64# ds3_a4oL 0#Int64 of {
__DEFAULT ->
GHC.Maybe.Just
@Int
(ghc-prim:GHC.Types.I# (ghc-prim:GHC.Prim.int64ToInt# ds3_a4oL));
1# -> GHC.Maybe.Nothing @Int
}
}
}}]
BenchShort.benchShort_eta2
= \ (sbs_a4oB :: ShortByteString) ->
case sbs_a4oB
`cast` (Data.ByteString.Short.Internal.N:ShortByteString[0]
:: ShortByteString ~R# Data.Array.Byte.ByteArray)
of
{ Data.Array.Byte.ByteArray ba#_a4oD ->
case {__ffi_static_ccall_unsafe bytestring-0.11.3.1-inplace:sbs_elem_index :: ByteArray#
-> Word8#
-> Word64#
-> State# RealWorld
-> (# State# RealWorld,
Int64# #)}_a4oG
ba#_a4oD
10#Word8
(ghc-prim:GHC.Prim.int64ToWord64#
(ghc-prim:GHC.Prim.intToInt64#
(ghc-prim:GHC.Prim.sizeofByteArray# ba#_a4oD)))
ghc-prim:GHC.Prim.realWorld#
of
{ (# ds2_a4oK, ds3_a4oL #) ->
case ghc-prim:GHC.Prim.ltInt64# ds3_a4oL 0#Int64 of {
__DEFAULT ->
GHC.Maybe.Just
@Int
(ghc-prim:GHC.Types.I# (ghc-prim:GHC.Prim.int64ToInt# ds3_a4oL));
1# -> GHC.Maybe.Nothing @Int
}
}
}
-- RHS size: {terms: 42, types: 18, coercions: 0, joins: 0/2}
BenchShort.$weta3 [InlPrag=[2]]
:: ghc-prim:GHC.Prim.ByteArray# -> Maybe Int
[GblId,
Arity=1,
Str=<L>,
Unf=Unf{Src=<vanilla>, TopLvl=True,
Value=True, ConLike=True, WorkFree=True, Expandable=True,
Guidance=IF_ARGS [0] 176 20}]
BenchShort.$weta3
= \ (ww_s4zT :: ghc-prim:GHC.Prim.ByteArray#) ->
let {
l_a4xv :: ghc-prim:GHC.Prim.Int#
[LclId]
l_a4xv = ghc-prim:GHC.Prim.sizeofByteArray# ww_s4zT } in
letrec {
$sgo_a4xw [Occ=LoopBreaker, Dmd=SC(S,L)]
:: ghc-prim:GHC.Prim.Int# -> [Int]
[LclId, Arity=1, Str=<L>, Unf=OtherCon []]
$sgo_a4xw
= \ (sc_a4xx :: ghc-prim:GHC.Prim.Int#) ->
case ghc-prim:GHC.Prim.>=# sc_a4xx l_a4xv of {
__DEFAULT ->
case ghc-prim:GHC.Prim.indexWord8Array# ww_s4zT sc_a4xx of ds_a4xz
{ __DEFAULT ->
case ghc-prim:GHC.Prim.word8ToWord# ds_a4xz of {
__DEFAULT -> $sgo_a4xw (ghc-prim:GHC.Prim.+# sc_a4xx 1#);
10## ->
ghc-prim:GHC.Types.:
@Int
(ghc-prim:GHC.Types.I# sc_a4xx)
($sgo_a4xw (ghc-prim:GHC.Prim.+# sc_a4xx 1#))
}
};
1# -> ghc-prim:GHC.Types.[] @Int
}; } in
case $sgo_a4xw 0# of {
[] -> GHC.Maybe.Nothing @Int;
: y_i4zs ys_i4zt -> GHC.Maybe.Just @Int y_i4zs
}
-- RHS size: {terms: 6, types: 3, coercions: 1, joins: 0/0}
BenchShort.benchShort_eta4 [InlPrag=[2]]
:: ShortByteString -> Maybe Int
[GblId,
Arity=1,
Str=<1!P(L)>,
Unf=Unf{Src=StableSystem, TopLvl=True,
Value=True, ConLike=True, WorkFree=True, Expandable=True,
Guidance=ALWAYS_IF(arity=1,unsat_ok=True,boring_ok=False)
Tmpl= \ (x_s4zR [Occ=Once1!] :: ShortByteString) ->
case x_s4zR
`cast` (Data.ByteString.Short.Internal.N:ShortByteString[0]
:: ShortByteString ~R# Data.Array.Byte.ByteArray)
of
{ Data.Array.Byte.ByteArray ww_s4zT [Occ=Once1] ->
BenchShort.$weta3 ww_s4zT
}}]
BenchShort.benchShort_eta4
= \ (x_s4zR :: ShortByteString) ->
case x_s4zR
`cast` (Data.ByteString.Short.Internal.N:ShortByteString[0]
:: ShortByteString ~R# Data.Array.Byte.ByteArray)
of
{ Data.Array.Byte.ByteArray ww_s4zT ->
BenchShort.$weta3 ww_s4zT
}
-- RHS size: {terms: 1, types: 0, coercions: 0, joins: 0/0}
BenchShort.benchShort48 :: ghc-prim:GHC.Prim.Addr#
[GblId,
Unf=Unf{Src=<vanilla>, TopLvl=True,
Value=True, ConLike=True, WorkFree=True, Expandable=True,
Guidance=IF_ARGS [] 50 0}]
BenchShort.benchShort48 = "ShortByteString"#
-- RHS size: {terms: 2, types: 0, coercions: 0, joins: 0/0}
BenchShort.benchShort47 :: [Char]
[GblId,
Unf=Unf{Src=<vanilla>, TopLvl=True,
Value=False, ConLike=True, WorkFree=False, Expandable=True,
Guidance=IF_ARGS [] 20 0}]
BenchShort.benchShort47
= ghc-prim:GHC.CString.unpackCString# BenchShort.benchShort48
-- RHS size: {terms: 1, types: 0, coercions: 0, joins: 0/0}
nilEq [InlPrag=NOINLINE] :: Word8 -> Word8 -> Bool
[GblId, Arity=2, Str=<1!P(L)><1!P(L)>, Unf=OtherCon []]
nilEq = GHC.Word.eqWord8
-- RHS size: {terms: 38, types: 11, coercions: 0, joins: 0/2}
BenchShort.$weta [InlPrag=[2]]
:: ghc-prim:GHC.Prim.ByteArray# -> [Int]
[GblId,
Arity=1,
Str=<L>,
Unf=Unf{Src=<vanilla>, TopLvl=True,
Value=True, ConLike=True, WorkFree=True, Expandable=True,
Guidance=IF_ARGS [0] 185 0}]
BenchShort.$weta
= \ (ww_s4Bu :: ghc-prim:GHC.Prim.ByteArray#) ->
let {
l_a4xv :: ghc-prim:GHC.Prim.Int#
[LclId]
l_a4xv = ghc-prim:GHC.Prim.sizeofByteArray# ww_s4Bu } in
letrec {
$sgo_a4xw [Occ=LoopBreaker, Dmd=SC(S,L)]
:: ghc-prim:GHC.Prim.Int# -> [Int]
[LclId, Arity=1, Str=<L>, Unf=OtherCon []]
$sgo_a4xw
= \ (sc_a4xx :: ghc-prim:GHC.Prim.Int#) ->
case ghc-prim:GHC.Prim.>=# sc_a4xx l_a4xv of {
__DEFAULT ->
case ghc-prim:GHC.Prim.indexWord8Array# ww_s4Bu sc_a4xx of ds_a4xz
{ __DEFAULT ->
case nilEq BenchShort.benchShort18 (GHC.Word.W8# ds_a4xz) of {
False -> $sgo_a4xw (ghc-prim:GHC.Prim.+# sc_a4xx 1#);
True ->
ghc-prim:GHC.Types.:
@Int
(ghc-prim:GHC.Types.I# sc_a4xx)
($sgo_a4xw (ghc-prim:GHC.Prim.+# sc_a4xx 1#))
}
};
1# -> ghc-prim:GHC.Types.[] @Int
}; } in
$sgo_a4xw 0#
-- RHS size: {terms: 6, types: 3, coercions: 1, joins: 0/0}
BenchShort.benchShort_eta [InlPrag=[2]] :: ShortByteString -> [Int]
[GblId,
Arity=1,
Str=<1!P(L)>,
Unf=Unf{Src=StableSystem, TopLvl=True,
Value=True, ConLike=True, WorkFree=True, Expandable=True,
Guidance=ALWAYS_IF(arity=1,unsat_ok=True,boring_ok=False)
Tmpl= \ (sbs_s4Bs [Occ=Once1!] :: ShortByteString) ->
case sbs_s4Bs
`cast` (Data.ByteString.Short.Internal.N:ShortByteString[0]
:: ShortByteString ~R# Data.Array.Byte.ByteArray)
of
{ Data.Array.Byte.ByteArray ww_s4Bu [Occ=Once1] ->
BenchShort.$weta ww_s4Bu
}}]
BenchShort.benchShort_eta
= \ (sbs_s4Bs :: ShortByteString) ->
case sbs_s4Bs
`cast` (Data.ByteString.Short.Internal.N:ShortByteString[0]
:: ShortByteString ~R# Data.Array.Byte.ByteArray)
of
{ Data.Array.Byte.ByteArray ww_s4Bu ->
BenchShort.$weta ww_s4Bu
}
-- RHS size: {terms: 697, types: 689, coercions: 2, joins: 0/30}
absurdlong :: ShortByteString
[GblId]
absurdlong
= ghc-prim:GHC.Magic.runRW#
@ghc-prim:GHC.Types.LiftedRep
@ShortByteString
(\ (s_a4jG [OS=OneShot]
:: ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld) ->
case ghc-prim:GHC.Prim.newByteArray#
@ghc-prim:GHC.Prim.RealWorld 999999# s_a4jG
of
{ (# ipv_a4jI, ipv1_a4jJ #) ->
case ghc-prim:GHC.Prim.setByteArray#
@ghc-prim:GHC.Prim.RealWorld ipv1_a4jJ 0# 999999# 102# ipv_a4jI
of s'_a4jO
{ __DEFAULT ->
case ghc-prim:GHC.Prim.unsafeFreezeByteArray#
@ghc-prim:GHC.Prim.RealWorld ipv1_a4jJ s'_a4jO
of
{ (# ipv2_a4jQ, ipv3_a4jR #) ->
ghc-prim:GHC.Magic.runRW#
@ghc-prim:GHC.Types.LiftedRep
@ShortByteString
(\ (s1_a4jV [OS=OneShot]
:: ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld) ->
case ghc-prim:GHC.Prim.newByteArray#
@ghc-prim:GHC.Prim.RealWorld 1# s1_a4jV
of
{ (# ipv4_a4jX, ipv5_a4jY #) ->
case ghc-prim:GHC.Prim.writeWord8Array#
@ghc-prim:GHC.Prim.RealWorld ipv5_a4jY 0# 10#Word8 ipv4_a4jX
of s'1_a4k3
{ __DEFAULT ->
case ghc-prim:GHC.Prim.unsafeFreezeByteArray#
@ghc-prim:GHC.Prim.RealWorld ipv5_a4jY s'1_a4k3
of
{ (# ipv6_a4k5, ipv7_a4k6 #) ->
ghc-prim:GHC.Magic.runRW#
@ghc-prim:GHC.Types.LiftedRep
@ShortByteString
(\ (s2_a4jj [OS=OneShot]
:: ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld) ->
let {
ipv8_s4pa :: ghc-prim:GHC.Prim.Int#
[LclId]
ipv8_s4pa = ghc-prim:GHC.Prim.sizeofByteArray# ipv7_a4k6 } in
let {
ipv9_s4pc :: ghc-prim:GHC.Prim.Int#
[LclId]
ipv9_s4pc = ghc-prim:GHC.Prim.sizeofByteArray# ipv3_a4jR } in
let {
r_s4pe :: ghc-prim:GHC.Prim.Int#
[LclId]
r_s4pe = ghc-prim:GHC.Prim.+# ipv8_s4pa ipv9_s4pc } in
case ghc-prim:GHC.Prim.>=# r_s4pe 0# of {
__DEFAULT ->
case Data.ByteString.Short.Internal.append1 of wild_00 { };
1# ->
case ghc-prim:GHC.Prim.newByteArray#
@ghc-prim:GHC.Prim.RealWorld r_s4pe s2_a4jj
of
{ (# ipv10_a4jr, ipv11_a4js #) ->
case ghc-prim:GHC.Prim.copyByteArray#
@ghc-prim:GHC.Prim.RealWorld
ipv7_a4k6
0#
ipv11_a4js
0#
ipv8_s4pa
ipv10_a4jr
of s'2_a4ju
{ __DEFAULT ->
case ghc-prim:GHC.Prim.copyByteArray#
@ghc-prim:GHC.Prim.RealWorld
ipv3_a4jR
0#
ipv11_a4js
ipv8_s4pa
ipv9_s4pc
s'2_a4ju
of s'3_a4jv
{ __DEFAULT ->
case ghc-prim:GHC.Prim.unsafeFreezeByteArray#
@ghc-prim:GHC.Prim.RealWorld ipv11_a4js s'3_a4jv
of
{ (# ipv12_a4jx, ipv13_a4jy #) ->
ghc-prim:GHC.Magic.runRW#
@ghc-prim:GHC.Types.LiftedRep
@ShortByteString
(\ (s3_X1 [OS=OneShot]
:: ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld) ->
case ghc-prim:GHC.Prim.newByteArray#
@ghc-prim:GHC.Prim.RealWorld 200# s3_X1
of
{ (# ipv14_X3, ipv15_X4 #) ->
case ghc-prim:GHC.Prim.setByteArray#
@ghc-prim:GHC.Prim.RealWorld ipv15_X4 0# 200# 101# ipv14_X3
of s'4_X5
{ __DEFAULT ->
case ghc-prim:GHC.Prim.unsafeFreezeByteArray#
@ghc-prim:GHC.Prim.RealWorld ipv15_X4 s'4_X5
of
{ (# ipv16_X7, ipv17_X8 #) ->
ghc-prim:GHC.Magic.runRW#
@ghc-prim:GHC.Types.LiftedRep
@ShortByteString
(\ (s4_X9 [OS=OneShot]
:: ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld) ->
let {
ipv18_s4pg :: ghc-prim:GHC.Prim.Int#
[LclId]
ipv18_s4pg = ghc-prim:GHC.Prim.sizeofByteArray# ipv17_X8 } in
let {
ipv19_s4pi :: ghc-prim:GHC.Prim.Int#
[LclId]
ipv19_s4pi = ghc-prim:GHC.Prim.sizeofByteArray# ipv13_a4jy } in
let {
r1_s4pk :: ghc-prim:GHC.Prim.Int#
[LclId]
r1_s4pk = ghc-prim:GHC.Prim.+# ipv18_s4pg ipv19_s4pi } in
case ghc-prim:GHC.Prim.>=# r1_s4pk 0# of {
__DEFAULT ->
case Data.ByteString.Short.Internal.append1 of wild_00 { };
1# ->
case ghc-prim:GHC.Prim.newByteArray#
@ghc-prim:GHC.Prim.RealWorld r1_s4pk s4_X9
of
{ (# ipv20_Xc, ipv21_Xd #) ->
case ghc-prim:GHC.Prim.copyByteArray#
@ghc-prim:GHC.Prim.RealWorld
ipv17_X8
0#
ipv21_Xd
0#
ipv18_s4pg
ipv20_Xc
of s'5_Xe
{ __DEFAULT ->
case ghc-prim:GHC.Prim.copyByteArray#
@ghc-prim:GHC.Prim.RealWorld
ipv13_a4jy
0#
ipv21_Xd
ipv18_s4pg
ipv19_s4pi
s'5_Xe
of s'6_Xf
{ __DEFAULT ->
case ghc-prim:GHC.Prim.unsafeFreezeByteArray#
@ghc-prim:GHC.Prim.RealWorld ipv21_Xd s'6_Xf
of
{ (# ipv22_Xh, ipv23_Xi #) ->
ghc-prim:GHC.Magic.runRW#
@ghc-prim:GHC.Types.LiftedRep
@ShortByteString
(\ (s5_Xj [OS=OneShot]
:: ghc-prim:GHC.Prim.State#
ghc-prim:GHC.Prim.RealWorld) ->
case ghc-prim:GHC.Prim.newByteArray#
@ghc-prim:GHC.Prim.RealWorld 1# s5_Xj
of
{ (# ipv24_Xl, ipv25_Xm #) ->
case ghc-prim:GHC.Prim.writeWord8Array#
@ghc-prim:GHC.Prim.RealWorld
ipv25_Xm
0#
10#Word8
ipv24_Xl
of s'7_Xn
{ __DEFAULT ->
case ghc-prim:GHC.Prim.unsafeFreezeByteArray#
@ghc-prim:GHC.Prim.RealWorld ipv25_Xm s'7_Xn
of
{ (# ipv26_Xp, ipv27_Xq #) ->
ghc-prim:GHC.Magic.runRW#
@ghc-prim:GHC.Types.LiftedRep
@ShortByteString
(\ (s6_Xr [OS=OneShot]
:: ghc-prim:GHC.Prim.State#
ghc-prim:GHC.Prim.RealWorld) ->
let {
ipv28_s4pm :: ghc-prim:GHC.Prim.Int#
[LclId]
ipv28_s4pm
= ghc-prim:GHC.Prim.sizeofByteArray#
ipv27_Xq } in
let {
ipv29_s4po :: ghc-prim:GHC.Prim.Int#
[LclId]
ipv29_s4po
= ghc-prim:GHC.Prim.sizeofByteArray#
ipv23_Xi } in
let {
r2_s4pq :: ghc-prim:GHC.Prim.Int#
[LclId]
r2_s4pq
= ghc-prim:GHC.Prim.+# ipv28_s4pm ipv29_s4po } in
case ghc-prim:GHC.Prim.>=# r2_s4pq 0# of {
__DEFAULT ->
case Data.ByteString.Short.Internal.append1
of wild_00 {
};
1# ->
case ghc-prim:GHC.Prim.newByteArray#
@ghc-prim:GHC.Prim.RealWorld r2_s4pq s6_Xr
of
{ (# ipv30_Xu, ipv31_Xv #) ->
case ghc-prim:GHC.Prim.copyByteArray#
@ghc-prim:GHC.Prim.RealWorld
ipv27_Xq
0#
ipv31_Xv
0#
ipv28_s4pm
ipv30_Xu
of s'8_Xw
{ __DEFAULT ->
case ghc-prim:GHC.Prim.copyByteArray#
@ghc-prim:GHC.Prim.RealWorld
ipv23_Xi
0#
ipv31_Xv
ipv28_s4pm
ipv29_s4po
s'8_Xw
of s'9_Xx
{ __DEFAULT ->
case ghc-prim:GHC.Prim.unsafeFreezeByteArray#
@ghc-prim:GHC.Prim.RealWorld
ipv31_Xv
s'9_Xx
of
{ (# ipv32_Xz, ipv33_XA #) ->
ghc-prim:GHC.Magic.runRW#
@ghc-prim:GHC.Types.LiftedRep
@ShortByteString
(\ (s7_XB [OS=OneShot]
:: ghc-prim:GHC.Prim.State#
ghc-prim:GHC.Prim.RealWorld) ->
case ghc-prim:GHC.Prim.newByteArray#
@ghc-prim:GHC.Prim.RealWorld
200#
s7_XB
of
{ (# ipv34_XD, ipv35_XE #) ->
case ghc-prim:GHC.Prim.setByteArray#
@ghc-prim:GHC.Prim.RealWorld
ipv35_XE
0#
200#
100#
ipv34_XD
of s'10_XF
{ __DEFAULT ->
case ghc-prim:GHC.Prim.unsafeFreezeByteArray#
@ghc-prim:GHC.Prim.RealWorld
ipv35_XE
s'10_XF
of
{ (# ipv36_XH, ipv37_XI #) ->
ghc-prim:GHC.Magic.runRW#
@ghc-prim:GHC.Types.LiftedRep
@ShortByteString
(\ (s8_XJ [OS=OneShot]
:: ghc-prim:GHC.Prim.State#
ghc-prim:GHC.Prim.RealWorld) ->
let {
ipv38_s4ps :: ghc-prim:GHC.Prim.Int#
[LclId]
ipv38_s4ps
= ghc-prim:GHC.Prim.sizeofByteArray#
ipv37_XI } in
let {
ipv39_s4pu :: ghc-prim:GHC.Prim.Int#
[LclId]
ipv39_s4pu
= ghc-prim:GHC.Prim.sizeofByteArray#
ipv33_XA } in
let {
r3_s4pw :: ghc-prim:GHC.Prim.Int#
[LclId]
r3_s4pw
= ghc-prim:GHC.Prim.+#
ipv38_s4ps ipv39_s4pu } in
case ghc-prim:GHC.Prim.>=# r3_s4pw 0#
of {
__DEFAULT ->
case Data.ByteString.Short.Internal.append1
of wild_00 {
};
1# ->
case ghc-prim:GHC.Prim.newByteArray#
@ghc-prim:GHC.Prim.RealWorld
r3_s4pw
s8_XJ
of
{ (# ipv40_XM, ipv41_XN #) ->
case ghc-prim:GHC.Prim.copyByteArray#
@ghc-prim:GHC.Prim.RealWorld
ipv37_XI
0#
ipv41_XN
0#
ipv38_s4ps
ipv40_XM
of s'11_XO
{ __DEFAULT ->
case ghc-prim:GHC.Prim.copyByteArray#
@ghc-prim:GHC.Prim.RealWorld
ipv33_XA
0#
ipv41_XN
ipv38_s4ps
ipv39_s4pu
s'11_XO
of s'12_XP
{ __DEFAULT ->
case ghc-prim:GHC.Prim.unsafeFreezeByteArray#
@ghc-prim:GHC.Prim.RealWorld
ipv41_XN
s'12_XP
of
{ (# ipv42_XR, ipv43_XS #) ->
ghc-prim:GHC.Magic.runRW#
@ghc-prim:GHC.Types.LiftedRep
@ShortByteString
(\ (s9_XT [OS=OneShot]
:: ghc-prim:GHC.Prim.State#
ghc-prim:GHC.Prim.RealWorld) ->
case ghc-prim:GHC.Prim.newByteArray#
@ghc-prim:GHC.Prim.RealWorld
1#
s9_XT
of
{ (# ipv44_XV, ipv45_XW #) ->
case ghc-prim:GHC.Prim.writeWord8Array#
@ghc-prim:GHC.Prim.RealWorld
ipv45_XW
0#
10#Word8
ipv44_XV
of s'13_XX
{ __DEFAULT ->
case ghc-prim:GHC.Prim.unsafeFreezeByteArray#
@ghc-prim:GHC.Prim.RealWorld
ipv45_XW
s'13_XX
of
{ (# ipv46_XZ, ipv47_X10 #) ->
ghc-prim:GHC.Magic.runRW#
@ghc-prim:GHC.Types.LiftedRep
@ShortByteString
(\ (s10_X11 [OS=OneShot]
:: ghc-prim:GHC.Prim.State#
ghc-prim:GHC.Prim.RealWorld) ->
let {
ipv48_s4py
:: ghc-prim:GHC.Prim.Int#
[LclId]
ipv48_s4py
= ghc-prim:GHC.Prim.sizeofByteArray#
ipv47_X10 } in
let {
ipv49_s4pA
:: ghc-prim:GHC.Prim.Int#
[LclId]
ipv49_s4pA
= ghc-prim:GHC.Prim.sizeofByteArray#
ipv43_XS } in
let {
r4_s4pC
:: ghc-prim:GHC.Prim.Int#
[LclId]
r4_s4pC
= ghc-prim:GHC.Prim.+#
ipv48_s4py
ipv49_s4pA } in
case ghc-prim:GHC.Prim.>=#
r4_s4pC 0#
of {
__DEFAULT ->
case Data.ByteString.Short.Internal.append1
of wild_00 {
};
1# ->
case ghc-prim:GHC.Prim.newByteArray#
@ghc-prim:GHC.Prim.RealWorld
r4_s4pC
s10_X11
of
{ (# ipv50_X14,
ipv51_X15 #) ->
case ghc-prim:GHC.Prim.copyByteArray#
@ghc-prim:GHC.Prim.RealWorld
ipv47_X10
0#
ipv51_X15
0#
ipv48_s4py
ipv50_X14
of s'14_X16
{ __DEFAULT ->
case ghc-prim:GHC.Prim.copyByteArray#
@ghc-prim:GHC.Prim.RealWorld
ipv43_XS
0#
ipv51_X15
ipv48_s4py
ipv49_s4pA
s'14_X16
of s'15_X17
{ __DEFAULT ->
case ghc-prim:GHC.Prim.unsafeFreezeByteArray#
@ghc-prim:GHC.Prim.RealWorld
ipv51_X15
s'15_X17
of
{ (# ipv52_X19,
ipv53_X1a #) ->
ghc-prim:GHC.Magic.runRW#
@ghc-prim:GHC.Types.LiftedRep
@ShortByteString
(\ (s11_X1b [OS=OneShot]
:: ghc-prim:GHC.Prim.State#
ghc-prim:GHC.Prim.RealWorld) ->
case ghc-prim:GHC.Prim.newByteArray#
@ghc-prim:GHC.Prim.RealWorld
200#
s11_X1b
of
{ (# ipv54_X1d,
ipv55_X1e #) ->
case ghc-prim:GHC.Prim.setByteArray#
@ghc-prim:GHC.Prim.RealWorld
ipv55_X1e
0#
200#
99#
ipv54_X1d
of s'16_X1f
{ __DEFAULT ->
case ghc-prim:GHC.Prim.unsafeFreezeByteArray#
@ghc-prim:GHC.Prim.RealWorld
ipv55_X1e
s'16_X1f
of
{ (# ipv56_X1h,
ipv57_X1i #) ->
ghc-prim:GHC.Magic.runRW#
@ghc-prim:GHC.Types.LiftedRep
@ShortByteString
(\ (s12_X1j [OS=OneShot]
:: ghc-prim:GHC.Prim.State#
ghc-prim:GHC.Prim.RealWorld) ->
let {
ipv58_s4pE
:: ghc-prim:GHC.Prim.Int#
[LclId]
ipv58_s4pE
= ghc-prim:GHC.Prim.sizeofByteArray#
ipv57_X1i } in
let {
ipv59_s4pG
:: ghc-prim:GHC.Prim.Int#
[LclId]
ipv59_s4pG
= ghc-prim:GHC.Prim.sizeofByteArray#
ipv53_X1a } in
let {
r5_s4pI
:: ghc-prim:GHC.Prim.Int#
[LclId]
r5_s4pI
= ghc-prim:GHC.Prim.+#
ipv58_s4pE
ipv59_s4pG } in
case ghc-prim:GHC.Prim.>=#
r5_s4pI
0#
of {
__DEFAULT ->
case Data.ByteString.Short.Internal.append1
of wild_00 {
};
1# ->
case ghc-prim:GHC.Prim.newByteArray#
@ghc-prim:GHC.Prim.RealWorld
r5_s4pI
s12_X1j
of
{ (# ipv60_X1m,
ipv61_X1n #) ->
case ghc-prim:GHC.Prim.copyByteArray#
@ghc-prim:GHC.Prim.RealWorld
ipv57_X1i
0#
ipv61_X1n
0#
ipv58_s4pE
ipv60_X1m
of s'17_X1o
{ __DEFAULT ->
case ghc-prim:GHC.Prim.copyByteArray#
@ghc-prim:GHC.Prim.RealWorld
ipv53_X1a
0#
ipv61_X1n
ipv58_s4pE
ipv59_s4pG
s'17_X1o
of s'18_X1p
{ __DEFAULT ->
case ghc-prim:GHC.Prim.unsafeFreezeByteArray#
@ghc-prim:GHC.Prim.RealWorld
ipv61_X1n
s'18_X1p
of
{ (# ipv62_X1r,
ipv63_X1s #) ->
ghc-prim:GHC.Magic.runRW#
@ghc-prim:GHC.Types.LiftedRep
@ShortByteString
(\ (s13_X1t [OS=OneShot]
:: ghc-prim:GHC.Prim.State#
ghc-prim:GHC.Prim.RealWorld) ->
case ghc-prim:GHC.Prim.newByteArray#
@ghc-prim:GHC.Prim.RealWorld
1#
s13_X1t
of
{ (# ipv64_X1v,
ipv65_X1w #) ->
case ghc-prim:GHC.Prim.writeWord8Array#
@ghc-prim:GHC.Prim.RealWorld
ipv65_X1w
0#
10#Word8
ipv64_X1v
of s'19_X1x
{ __DEFAULT ->
case ghc-prim:GHC.Prim.unsafeFreezeByteArray#
@ghc-prim:GHC.Prim.RealWorld
ipv65_X1w
s'19_X1x
of
{ (# ipv66_X1z,
ipv67_X1A #) ->
ghc-prim:GHC.Magic.runRW#
@ghc-prim:GHC.Types.LiftedRep
@ShortByteString
(\ (s14_X1B [OS=OneShot]
:: ghc-prim:GHC.Prim.State#
ghc-prim:GHC.Prim.RealWorld) ->
let {
ipv68_s4pK
:: ghc-prim:GHC.Prim.Int#
[LclId]
ipv68_s4pK
= ghc-prim:GHC.Prim.sizeofByteArray#
ipv67_X1A } in
let {
ipv69_s4pM
:: ghc-prim:GHC.Prim.Int#
[LclId]
ipv69_s4pM
= ghc-prim:GHC.Prim.sizeofByteArray#
ipv63_X1s } in
let {
r6_s4pO
:: ghc-prim:GHC.Prim.Int#
[LclId]
r6_s4pO
= ghc-prim:GHC.Prim.+#
ipv68_s4pK
ipv69_s4pM } in
case ghc-prim:GHC.Prim.>=#
r6_s4pO
0#
of {
__DEFAULT ->
case Data.ByteString.Short.Internal.append1
of wild_00 {
};
1# ->
case ghc-prim:GHC.Prim.newByteArray#
@ghc-prim:GHC.Prim.RealWorld
r6_s4pO
s14_X1B
of
{ (# ipv70_X1E,
ipv71_X1F #) ->
case ghc-prim:GHC.Prim.copyByteArray#
@ghc-prim:GHC.Prim.RealWorld
ipv67_X1A
0#
ipv71_X1F
0#
ipv68_s4pK
ipv70_X1E
of s'20_X1G
{ __DEFAULT ->
case ghc-prim:GHC.Prim.copyByteArray#
@ghc-prim:GHC.Prim.RealWorld
ipv63_X1s
0#
ipv71_X1F
ipv68_s4pK
ipv69_s4pM
s'20_X1G
of s'21_X1H
{ __DEFAULT ->
case ghc-prim:GHC.Prim.unsafeFreezeByteArray#
@ghc-prim:GHC.Prim.RealWorld
ipv71_X1F
s'21_X1H
of
{ (# ipv72_X1J,
ipv73_X1K #) ->
ghc-prim:GHC.Magic.runRW#
@ghc-prim:GHC.Types.LiftedRep
@ShortByteString
(\ (s15_X1L [OS=OneShot]
:: ghc-prim:GHC.Prim.State#
ghc-prim:GHC.Prim.RealWorld) ->
case ghc-prim:GHC.Prim.newByteArray#
@ghc-prim:GHC.Prim.RealWorld
200#
s15_X1L
of
{ (# ipv74_X1N,
ipv75_X1O #) ->
case ghc-prim:GHC.Prim.setByteArray#
@ghc-prim:GHC.Prim.RealWorld
ipv75_X1O
0#
200#
98#
ipv74_X1N
of s'22_X1P
{ __DEFAULT ->
case ghc-prim:GHC.Prim.unsafeFreezeByteArray#
@ghc-prim:GHC.Prim.RealWorld
ipv75_X1O
s'22_X1P
of
{ (# ipv76_X1R,
ipv77_X1S #) ->
ghc-prim:GHC.Magic.runRW#
@ghc-prim:GHC.Types.LiftedRep
@ShortByteString
(\ (s16_X1T [OS=OneShot]
:: ghc-prim:GHC.Prim.State#
ghc-prim:GHC.Prim.RealWorld) ->
let {
ipv78_s4pQ
:: ghc-prim:GHC.Prim.Int#
[LclId]
ipv78_s4pQ
= ghc-prim:GHC.Prim.sizeofByteArray#
ipv77_X1S } in
let {
ipv79_s4pS
:: ghc-prim:GHC.Prim.Int#
[LclId]
ipv79_s4pS
= ghc-prim:GHC.Prim.sizeofByteArray#
ipv73_X1K } in
let {
r7_s4pU
:: ghc-prim:GHC.Prim.Int#
[LclId]
r7_s4pU
= ghc-prim:GHC.Prim.+#
ipv78_s4pQ
ipv79_s4pS } in
case ghc-prim:GHC.Prim.>=#
r7_s4pU
0#
of {
__DEFAULT ->
case Data.ByteString.Short.Internal.append1
of wild_00 {
};
1# ->
case ghc-prim:GHC.Prim.newByteArray#
@ghc-prim:GHC.Prim.RealWorld
r7_s4pU
s16_X1T
of
{ (# ipv80_X1W,
ipv81_X1X #) ->
case ghc-prim:GHC.Prim.copyByteArray#
@ghc-prim:GHC.Prim.RealWorld
ipv77_X1S
0#
ipv81_X1X
0#
ipv78_s4pQ
ipv80_X1W
of s'23_X1Y
{ __DEFAULT ->
case ghc-prim:GHC.Prim.copyByteArray#
@ghc-prim:GHC.Prim.RealWorld
ipv73_X1K
0#
ipv81_X1X
ipv78_s4pQ
ipv79_s4pS
s'23_X1Y
of s'24_X1Z
{ __DEFAULT ->
case ghc-prim:GHC.Prim.unsafeFreezeByteArray#
@ghc-prim:GHC.Prim.RealWorld
ipv81_X1X
s'24_X1Z
of
{ (# ipv82_X21,
ipv83_X22 #) ->
ghc-prim:GHC.Magic.runRW#
@ghc-prim:GHC.Types.LiftedRep
@ShortByteString
(\ (s17_X23 [OS=OneShot]
:: ghc-prim:GHC.Prim.State#
ghc-prim:GHC.Prim.RealWorld) ->
case ghc-prim:GHC.Prim.newByteArray#
@ghc-prim:GHC.Prim.RealWorld
1#
s17_X23
of
{ (# ipv84_X25,
ipv85_X26 #) ->
case ghc-prim:GHC.Prim.writeWord8Array#
@ghc-prim:GHC.Prim.RealWorld
ipv85_X26
0#
10#Word8
ipv84_X25
of s'25_X27
{ __DEFAULT ->
case ghc-prim:GHC.Prim.unsafeFreezeByteArray#
@ghc-prim:GHC.Prim.RealWorld
ipv85_X26
s'25_X27
of
{ (# ipv86_X29,
ipv87_X2a #) ->
ghc-prim:GHC.Magic.runRW#
@ghc-prim:GHC.Types.LiftedRep
@ShortByteString
(\ (s18_X2b [OS=OneShot]
:: ghc-prim:GHC.Prim.State#
ghc-prim:GHC.Prim.RealWorld) ->
let {
ipv88_s4pW
:: ghc-prim:GHC.Prim.Int#
[LclId]
ipv88_s4pW
= ghc-prim:GHC.Prim.sizeofByteArray#
ipv87_X2a } in
let {
ipv89_s4pY
:: ghc-prim:GHC.Prim.Int#
[LclId]
ipv89_s4pY
= ghc-prim:GHC.Prim.sizeofByteArray#
ipv83_X22 } in
let {
r8_s4q0
:: ghc-prim:GHC.Prim.Int#
[LclId]
r8_s4q0
= ghc-prim:GHC.Prim.+#
ipv88_s4pW
ipv89_s4pY } in
case ghc-prim:GHC.Prim.>=#
r8_s4q0
0#
of {
__DEFAULT ->
case Data.ByteString.Short.Internal.append1
of wild_00 {
};
1# ->
case ghc-prim:GHC.Prim.newByteArray#
@ghc-prim:GHC.Prim.RealWorld
r8_s4q0
s18_X2b
of
{ (# ipv90_X2e,
ipv91_X2f #) ->
case ghc-prim:GHC.Prim.copyByteArray#
@ghc-prim:GHC.Prim.RealWorld
ipv87_X2a
0#
ipv91_X2f
0#
ipv88_s4pW
ipv90_X2e
of s'26_X2g
{ __DEFAULT ->
case ghc-prim:GHC.Prim.copyByteArray#
@ghc-prim:GHC.Prim.RealWorld
ipv83_X22
0#
ipv91_X2f
ipv88_s4pW
ipv89_s4pY
s'26_X2g
of s'27_X2h
{ __DEFAULT ->
case ghc-prim:GHC.Prim.unsafeFreezeByteArray#
@ghc-prim:GHC.Prim.RealWorld
ipv91_X2f
s'27_X2h
of
{ (# ipv92_X2j,
ipv93_X2k #) ->
ghc-prim:GHC.Magic.runRW#
@ghc-prim:GHC.Types.LiftedRep
@ShortByteString
(\ (s19_X2l [OS=OneShot]
:: ghc-prim:GHC.Prim.State#
ghc-prim:GHC.Prim.RealWorld) ->
case ghc-prim:GHC.Prim.newByteArray#
@ghc-prim:GHC.Prim.RealWorld
200#
s19_X2l
of
{ (# ipv94_X2n,
ipv95_X2o #) ->
case ghc-prim:GHC.Prim.setByteArray#
@ghc-prim:GHC.Prim.RealWorld
ipv95_X2o
0#
200#
97#
ipv94_X2n
of s'28_X2p
{ __DEFAULT ->
case ghc-prim:GHC.Prim.unsafeFreezeByteArray#
@ghc-prim:GHC.Prim.RealWorld
ipv95_X2o
s'28_X2p
of
{ (# ipv96_X2r,
ipv97_X2s #) ->
ghc-prim:GHC.Magic.runRW#
@ghc-prim:GHC.Types.LiftedRep
@ShortByteString
(\ (s20_X2t [OS=OneShot]
:: ghc-prim:GHC.Prim.State#
ghc-prim:GHC.Prim.RealWorld) ->
let {
ipv98_s4q2
:: ghc-prim:GHC.Prim.Int#
[LclId]
ipv98_s4q2
= ghc-prim:GHC.Prim.sizeofByteArray#
ipv97_X2s } in
let {
ipv99_s4q4
:: ghc-prim:GHC.Prim.Int#
[LclId]
ipv99_s4q4
= ghc-prim:GHC.Prim.sizeofByteArray#
ipv93_X2k } in
let {
r9_s4q6
:: ghc-prim:GHC.Prim.Int#
[LclId]
r9_s4q6
= ghc-prim:GHC.Prim.+#
ipv98_s4q2
ipv99_s4q4 } in
case ghc-prim:GHC.Prim.>=#
r9_s4q6
0#
of {
__DEFAULT ->
case Data.ByteString.Short.Internal.append1
of wild_00 {
};
1# ->
case ghc-prim:GHC.Prim.newByteArray#
@ghc-prim:GHC.Prim.RealWorld
r9_s4q6
s20_X2t
of
{ (# ipv100_X2w,
ipv101_X2x #) ->
case ghc-prim:GHC.Prim.copyByteArray#
@ghc-prim:GHC.Prim.RealWorld
ipv97_X2s
0#
ipv101_X2x
0#
ipv98_s4q2
ipv100_X2w
of s'29_X2y
{ __DEFAULT ->
case ghc-prim:GHC.Prim.copyByteArray#
@ghc-prim:GHC.Prim.RealWorld
ipv93_X2k
0#
ipv101_X2x
ipv98_s4q2
ipv99_s4q4
s'29_X2y
of s'30_X2z
{ __DEFAULT ->
case ghc-prim:GHC.Prim.unsafeFreezeByteArray#
@ghc-prim:GHC.Prim.RealWorld
ipv101_X2x
s'30_X2z
of
{ (# ipv102_X2B,
ipv103_X2C #) ->
(Data.Array.Byte.ByteArray
ipv103_X2C)
`cast` (Sym (Data.ByteString.Short.Internal.N:ShortByteString[0])
:: Data.Array.Byte.ByteArray
~R# ShortByteString)
}
}
}
}
})
}
}
})
}
}
}
}
})
}
}
})
}
}
}
}
})
}
}
})
}
}
}
}
})
}
}
})
}
}
}
}
})
}
}
})
}
}
}
}
})
}
}
})
}
}
}
}
})
}
}
})
}
}
}
}
})
}
}
})
}
}
}
}
})
}
}
})
}
}
}
}
})
}
}
})
}
}
})
-- RHS size: {terms: 32, types: 11, coercions: 0, joins: 1/2}
BenchShort.$wfind_index [InlPrag=[2]]
:: ghc-prim:GHC.Prim.ByteArray# -> Maybe Int
[GblId,
Arity=1,
Str=<L>,
Unf=Unf{Src=<vanilla>, TopLvl=True,
Value=True, ConLike=True, WorkFree=True, Expandable=True,
Guidance=IF_ARGS [0] 73 0}]
BenchShort.$wfind_index
= \ (ww_s4zJ :: ghc-prim:GHC.Prim.ByteArray#) ->
let {
l_s4DN :: ghc-prim:GHC.Prim.Int#
[LclId]
l_s4DN = ghc-prim:GHC.Prim.sizeofByteArray# ww_s4zJ } in
joinrec {
$sgo_s4DY [Occ=LoopBreaker, Dmd=SC(S,L)]
:: ghc-prim:GHC.Prim.Int# -> Maybe Int
[LclId[JoinId(1)(Nothing)], Arity=1, Str=<L>, Unf=OtherCon []]
$sgo_s4DY (sc_s4DX :: ghc-prim:GHC.Prim.Int#)
= case ghc-prim:GHC.Prim.>=# sc_s4DX l_s4DN of {
__DEFAULT ->
case ghc-prim:GHC.Prim.indexWord8Array# ww_s4zJ sc_s4DX of ds_a4c0
{ __DEFAULT ->
case ghc-prim:GHC.Prim.word8ToWord# ds_a4c0 of {
__DEFAULT -> jump $sgo_s4DY (ghc-prim:GHC.Prim.+# sc_s4DX 1#);
10## -> GHC.Maybe.Just @Int (ghc-prim:GHC.Types.I# sc_s4DX)
}
};
1# -> GHC.Maybe.Nothing @Int
}; } in
jump $sgo_s4DY 0#
-- RHS size: {terms: 6, types: 3, coercions: 1, joins: 0/0}
find_index [InlPrag=[2]] :: ShortByteString -> Maybe Int
[GblId,
Arity=1,
Str=<1!P(L)>,
Unf=Unf{Src=StableSystem, TopLvl=True,
Value=True, ConLike=True, WorkFree=True, Expandable=True,
Guidance=ALWAYS_IF(arity=1,unsat_ok=True,boring_ok=False)
Tmpl= \ (s_s4zH [Occ=Once1!] :: ShortByteString) ->
case s_s4zH
`cast` (Data.ByteString.Short.Internal.N:ShortByteString[0]
:: ShortByteString ~R# Data.Array.Byte.ByteArray)
of
{ Data.Array.Byte.ByteArray ww_s4zJ [Occ=Once1] ->
BenchShort.$wfind_index ww_s4zJ
}}]
find_index
= \ (s_s4zH :: ShortByteString) ->
case s_s4zH
`cast` (Data.ByteString.Short.Internal.N:ShortByteString[0]
:: ShortByteString ~R# Data.Array.Byte.ByteArray)
of
{ Data.Array.Byte.ByteArray ww_s4zJ ->
BenchShort.$wfind_index ww_s4zJ
}
-- RHS size: {terms: 32, types: 11, coercions: 0, joins: 1/2}
BenchShort.$weta2 [InlPrag=[2]]
:: ghc-prim:GHC.Prim.ByteArray# -> Maybe Int
[GblId,
Arity=1,
Str=<L>,
Unf=Unf{Src=<vanilla>, TopLvl=True,
Value=True, ConLike=True, WorkFree=True, Expandable=True,
Guidance=IF_ARGS [0] 73 0}]
BenchShort.$weta2
= \ (ww_s4Al :: ghc-prim:GHC.Prim.ByteArray#) ->
let {
l_s4DQ :: ghc-prim:GHC.Prim.Int#
[LclId]
l_s4DQ = ghc-prim:GHC.Prim.sizeofByteArray# ww_s4Al } in
joinrec {
$sgo_s4E4 [Occ=LoopBreaker, Dmd=SC(S,L)]
:: ghc-prim:GHC.Prim.Int# -> Maybe Int
[LclId[JoinId(1)(Nothing)], Arity=1, Str=<L>, Unf=OtherCon []]
$sgo_s4E4 (sc_s4E3 :: ghc-prim:GHC.Prim.Int#)
= case ghc-prim:GHC.Prim.>=# sc_s4E3 l_s4DQ of {
__DEFAULT ->
case ghc-prim:GHC.Prim.indexWord8Array# ww_s4Al sc_s4E3 of ds_a4c0
{ __DEFAULT ->
case ghc-prim:GHC.Prim.word8ToWord# ds_a4c0 of {
__DEFAULT -> jump $sgo_s4E4 (ghc-prim:GHC.Prim.+# sc_s4E3 1#);
10## -> GHC.Maybe.Just @Int (ghc-prim:GHC.Types.I# sc_s4E3)
}
};
1# -> GHC.Maybe.Nothing @Int
}; } in
jump $sgo_s4E4 0#
-- RHS size: {terms: 6, types: 3, coercions: 1, joins: 0/0}
BenchShort.benchShort_eta3 [InlPrag=[2]]
:: ShortByteString -> Maybe Int
[GblId,
Arity=1,
Str=<1!P(L)>,
Unf=Unf{Src=StableSystem, TopLvl=True,
Value=True, ConLike=True, WorkFree=True, Expandable=True,
Guidance=ALWAYS_IF(arity=1,unsat_ok=True,boring_ok=False)
Tmpl= \ (sbs_s4Aj [Occ=Once1!] :: ShortByteString) ->
case sbs_s4Aj
`cast` (Data.ByteString.Short.Internal.N:ShortByteString[0]
:: ShortByteString ~R# Data.Array.Byte.ByteArray)
of
{ Data.Array.Byte.ByteArray ww_s4Al [Occ=Once1] ->
BenchShort.$weta2 ww_s4Al
}}]
BenchShort.benchShort_eta3
= \ (sbs_s4Aj :: ShortByteString) ->
case sbs_s4Aj
`cast` (Data.ByteString.Short.Internal.N:ShortByteString[0]
:: ShortByteString ~R# Data.Array.Byte.ByteArray)
of
{ Data.Array.Byte.ByteArray ww_s4Al ->
BenchShort.$weta2 ww_s4Al
}
Rec {
-- RHS size: {terms: 42, types: 33, coercions: 1, joins: 0/0}
BenchShort.benchShort_$s$wbenchLoop [Occ=LoopBreaker]
:: ShortByteString
-> ghc-prim:GHC.Prim.Word64#
-> ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld
-> ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld
[GblId, Arity=3, Str=<L><1L><L>, Unf=OtherCon []]
BenchShort.benchShort_$s$wbenchLoop
= \ (x_s4zZ :: ShortByteString)
(ww_s4A2 :: ghc-prim:GHC.Prim.Word64#)
(eta_s4A4 [OS=OneShot]
:: ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld) ->
case ww_s4A2 of wild_X1 {
__DEFAULT ->
case ghc-prim:GHC.Prim.seq#
@(Maybe Int)
@ghc-prim:GHC.Prim.RealWorld
(case x_s4zZ
`cast` (Data.ByteString.Short.Internal.N:ShortByteString[0]
:: ShortByteString ~R# Data.Array.Byte.ByteArray)
of
{ Data.Array.Byte.ByteArray ba#_a4oD ->
case {__ffi_static_ccall_unsafe bytestring-0.11.3.1-inplace:sbs_elem_index :: ByteArray#
-> Word8#
-> Word64#
-> State# RealWorld
-> (# State# RealWorld,
Int64# #)}_a4oG
ba#_a4oD
10#Word8
(ghc-prim:GHC.Prim.int64ToWord64#
(ghc-prim:GHC.Prim.intToInt64#
(ghc-prim:GHC.Prim.sizeofByteArray# ba#_a4oD)))
ghc-prim:GHC.Prim.realWorld#
of
{ (# ds2_a4oK, ds3_a4oL #) ->
case ghc-prim:GHC.Prim.ltInt64# ds3_a4oL 0#Int64 of {
__DEFAULT ->
GHC.Maybe.Just
@Int
(ghc-prim:GHC.Types.I# (ghc-prim:GHC.Prim.int64ToInt# ds3_a4oL));
1# -> GHC.Maybe.Nothing @Int
}
}
})
eta_s4A4
of
{ (# ipv_i4kO, ipv1_i4kP #) ->
BenchShort.benchShort_$s$wbenchLoop
x_s4zZ (ghc-prim:GHC.Prim.subWord64# wild_X1 1#Word64) ipv_i4kO
};
0#Word64 -> eta_s4A4
}
end Rec }
Rec {
-- RHS size: {terms: 31, types: 27, coercions: 1, joins: 0/0}
BenchShort.benchShort_$s$wbenchLoop2 [Occ=LoopBreaker]
:: ShortByteString
-> ghc-prim:GHC.Prim.Word64#
-> ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld
-> ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld
[GblId, Arity=3, Str=<L><1L><L>, Unf=OtherCon []]
BenchShort.benchShort_$s$wbenchLoop2
= \ (x_s4zZ :: ShortByteString)
(ww_s4A2 :: ghc-prim:GHC.Prim.Word64#)
(eta_s4A4 [OS=OneShot]
:: ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld) ->
case ww_s4A2 of wild_X1 {
__DEFAULT ->
case ghc-prim:GHC.Prim.seq#
@(Maybe Int)
@ghc-prim:GHC.Prim.RealWorld
(case x_s4zZ
`cast` (Data.ByteString.Short.Internal.N:ShortByteString[0]
:: ShortByteString ~R# Data.Array.Byte.ByteArray)
of
{ Data.Array.Byte.ByteArray ww1_s4zT ->
case BenchShort.$weta3 ww1_s4zT of wild2_i48B {
Nothing -> GHC.Maybe.Nothing @Int;
Just x1_i48C ->
case x1_i48C of { ghc-prim:GHC.Types.I# ipv_i48h -> wild2_i48B }
}
})
eta_s4A4
of
{ (# ipv_i4kO, ipv1_i4kP #) ->
BenchShort.benchShort_$s$wbenchLoop2
x_s4zZ (ghc-prim:GHC.Prim.subWord64# wild_X1 1#Word64) ipv_i4kO
};
0#Word64 -> eta_s4A4
}
end Rec }
Rec {
-- RHS size: {terms: 66, types: 44, coercions: 1, joins: 2/4}
BenchShort.benchShort_$s$wbenchLoop1 [Occ=LoopBreaker]
:: ShortByteString
-> ghc-prim:GHC.Prim.Word64#
-> ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld
-> ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld
[GblId, Arity=3, Str=<L><1L><L>, Unf=OtherCon []]
BenchShort.benchShort_$s$wbenchLoop1
= \ (x_s4zZ :: ShortByteString)
(ww_s4A2 :: ghc-prim:GHC.Prim.Word64#)
(eta_s4A4 [OS=OneShot]
:: ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld) ->
case ww_s4A2 of wild_X1 {
__DEFAULT ->
case ghc-prim:GHC.Prim.seq#
@(Maybe Int)
@ghc-prim:GHC.Prim.RealWorld
(case x_s4zZ
`cast` (Data.ByteString.Short.Internal.N:ShortByteString[0]
:: ShortByteString ~R# Data.Array.Byte.ByteArray)
of
{ Data.Array.Byte.ByteArray ww1_s4Al ->
let {
l_s4DQ :: ghc-prim:GHC.Prim.Int#
[LclId]
l_s4DQ = ghc-prim:GHC.Prim.sizeofByteArray# ww1_s4Al } in
join {
$j_s4Fl [Dmd=LC(S,C(1,L))] :: Int -> Maybe Int -> Maybe Int
[LclId[JoinId(2)(Just [!, !])], Arity=2, Str=<1A><1L>]
$j_s4Fl (x1_i48C [OS=OneShot] :: Int)
(wild2_i48B [OS=OneShot] :: Maybe Int)
= case wild2_i48B of wild3_X3 { __DEFAULT ->
case x1_i48C of { ghc-prim:GHC.Types.I# ipv_i48h -> wild3_X3 }
} } in
joinrec {
$sgo_s4E4 [Occ=LoopBreaker, Dmd=SC(S,L)]
:: ghc-prim:GHC.Prim.Int# -> Maybe Int
[LclId[JoinId(1)(Nothing)], Arity=1, Str=<L>, Unf=OtherCon []]
$sgo_s4E4 (sc_s4E3 :: ghc-prim:GHC.Prim.Int#)
= case ghc-prim:GHC.Prim.>=# sc_s4E3 l_s4DQ of {
__DEFAULT ->
case ghc-prim:GHC.Prim.indexWord8Array# ww1_s4Al sc_s4E3 of ds_a4c0
{ __DEFAULT ->
case ghc-prim:GHC.Prim.word8ToWord# ds_a4c0 of {
__DEFAULT -> jump $sgo_s4E4 (ghc-prim:GHC.Prim.+# sc_s4E3 1#);
10## ->
let {
x1_i48C [Dmd=SL] :: Int
[LclId, Unf=OtherCon []]
x1_i48C = ghc-prim:GHC.Types.I# sc_s4E3 } in
jump $j_s4Fl x1_i48C (GHC.Maybe.Just @Int x1_i48C)
}
};
1# -> GHC.Maybe.Nothing @Int
}; } in
jump $sgo_s4E4 0#
})
eta_s4A4
of
{ (# ipv_i4kO, ipv1_i4kP #) ->
BenchShort.benchShort_$s$wbenchLoop1
x_s4zZ (ghc-prim:GHC.Prim.subWord64# wild_X1 1#Word64) ipv_i4kO
};
0#Word64 -> eta_s4A4
}
end Rec }
Rec {
-- RHS size: {terms: 30, types: 28, coercions: 0, joins: 0/0}
BenchShort.$wbenchLoop [InlPrag=[2], Occ=LoopBreaker]
:: (ShortByteString -> Maybe Int)
-> ShortByteString
-> ghc-prim:GHC.Prim.Word64#
-> ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld
-> ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld
[GblId, Arity=4, Str=<L><L><1L><L>, Unf=OtherCon []]
BenchShort.$wbenchLoop
= \ (f_s4zY :: ShortByteString -> Maybe Int)
(x_s4zZ :: ShortByteString)
(ww_s4A2 :: ghc-prim:GHC.Prim.Word64#)
(eta_s4A4 [OS=OneShot]
:: ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld) ->
case ww_s4A2 of wild_X1 {
__DEFAULT ->
case ghc-prim:GHC.Prim.seq#
@(Maybe Int)
@ghc-prim:GHC.Prim.RealWorld
(case f_s4zY x_s4zZ of wild1_i48B {
Nothing -> GHC.Maybe.Nothing @Int;
Just x1_i48C ->
case x1_i48C of { ghc-prim:GHC.Types.I# ipv_i48h -> wild1_i48B }
})
eta_s4A4
of
{ (# ipv_i4kO, ipv1_i4kP #) ->
BenchShort.$wbenchLoop
f_s4zY
x_s4zZ
(ghc-prim:GHC.Prim.subWord64# wild_X1 1#Word64)
ipv_i4kO
};
0#Word64 -> eta_s4A4
}
end Rec }
-- RHS size: {terms: 17, types: 16, coercions: 0, joins: 0/0}
BenchShort.benchShort10 [InlPrag=[2]]
:: (ShortByteString -> Maybe Int)
-> ShortByteString
-> Word64
-> ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld
-> (# ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld, () #)
[GblId[StrictWorker([~, ~, !])],
Arity=4,
Str=<L><L><1!P(1L)><L>,
Cpr=1(, 1),
Unf=Unf{Src=StableSystem, TopLvl=True,
Value=True, ConLike=True, WorkFree=True, Expandable=True,
Guidance=ALWAYS_IF(arity=4,unsat_ok=True,boring_ok=False)
Tmpl= \ (f_s4zY [Occ=Once1] :: ShortByteString -> Maybe Int)
(x_s4zZ [Occ=Once1] :: ShortByteString)
(n2_s4A0 [Occ=Once1!] :: Word64)
(eta_s4A4 [Occ=Once1, OS=OneShot]
:: ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld) ->
case n2_s4A0 of { GHC.Word.W64# ww_s4A2 [Occ=Once1] ->
case BenchShort.$wbenchLoop f_s4zY x_s4zZ ww_s4A2 eta_s4A4
of ww1_s4A7 [Occ=Once1]
{ __DEFAULT ->
(# ww1_s4A7, ghc-prim:GHC.Tuple.Prim.() #)
}
}}]
BenchShort.benchShort10
= \ (f_s4zY :: ShortByteString -> Maybe Int)
(x_s4zZ :: ShortByteString)
(n2_s4A0 :: Word64)
(eta_s4A4 [OS=OneShot]
:: ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld) ->
case n2_s4A0 of { GHC.Word.W64# ww_s4A2 ->
case BenchShort.$wbenchLoop f_s4zY x_s4zZ ww_s4A2 eta_s4A4
of ww1_s4A7
{ __DEFAULT ->
(# ww1_s4A7, ghc-prim:GHC.Tuple.Prim.() #)
}
}
-- RHS size: {terms: 14, types: 12, coercions: 0, joins: 0/0}
BenchShort.benchShort42
:: Word64
-> ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld
-> (# ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld, () #)
[GblId,
Arity=2,
Str=<1!P(1L)><L>,
Cpr=1(, 1),
Unf=Unf{Src=StableSystem, TopLvl=True,
Value=True, ConLike=True, WorkFree=True, Expandable=True,
Guidance=ALWAYS_IF(arity=2,unsat_ok=True,boring_ok=False)
Tmpl= \ (eta2_i4ky [Occ=Once1] :: Word64)
(eta3_i4kA [Occ=Once1, OS=OneShot]
:: ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld) ->
BenchShort.benchShort10
BenchShort.benchShort_eta4 absurdlong eta2_i4ky eta3_i4kA}]
BenchShort.benchShort42
= \ (eta2_i4ky :: Word64)
(eta3_i4kA [OS=OneShot]
:: ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld) ->
case eta2_i4ky of { GHC.Word.W64# ww_s4A2 ->
case BenchShort.benchShort_$s$wbenchLoop2
absurdlong ww_s4A2 eta3_i4kA
of ww1_s4A7
{ __DEFAULT ->
(# ww1_s4A7, ghc-prim:GHC.Tuple.Prim.() #)
}
}
-- RHS size: {terms: 4, types: 1, coercions: 9, joins: 0/0}
BenchShort.benchShort41
:: tasty-1.4.3-5ff128a6e1ca080f4ba7000442aac93484033725a048c7bebd631c80dacde107:Test.Tasty.Core.TestTree
[GblId,
Unf=Unf{Src=<vanilla>, TopLvl=True,
Value=True, ConLike=True, WorkFree=True, Expandable=True,
Guidance=IF_ARGS [] 10 10}]
BenchShort.benchShort41
= tasty-1.4.3-5ff128a6e1ca080f4ba7000442aac93484033725a048c7bebd631c80dacde107:Test.Tasty.Core.SingleTest
@Benchmarkable
Test.Tasty.Bench.$fIsTestBenchmarkable
BenchShort.benchShort43
(BenchShort.benchShort42
`cast` (<Word64>_R
%<Many>_N ->_R Sym (ghc-prim:GHC.Types.N:IO[0] <()>_R)
; Sym (Test.Tasty.Bench.N:Benchmarkable[0])
:: (Word64
-> ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld
-> (# ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld, () #))
~R# Benchmarkable))
-- RHS size: {terms: 14, types: 12, coercions: 0, joins: 0/0}
BenchShort.benchShort34
:: Word64
-> ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld
-> (# ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld, () #)
[GblId,
Arity=2,
Str=<1!P(1L)><L>,
Cpr=1(, 1),
Unf=Unf{Src=StableSystem, TopLvl=True,
Value=True, ConLike=True, WorkFree=True, Expandable=True,
Guidance=ALWAYS_IF(arity=2,unsat_ok=True,boring_ok=False)
Tmpl= \ (eta2_i4ky [Occ=Once1] :: Word64)
(eta3_i4kA [Occ=Once1, OS=OneShot]
:: ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld) ->
BenchShort.benchShort10
BenchShort.benchShort_eta2 absurdlong eta2_i4ky eta3_i4kA}]
BenchShort.benchShort34
= \ (eta2_i4ky :: Word64)
(eta3_i4kA [OS=OneShot]
:: ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld) ->
case eta2_i4ky of { GHC.Word.W64# ww_s4AP ->
case BenchShort.benchShort_$s$wbenchLoop
absurdlong ww_s4AP eta3_i4kA
of ww1_s4AU
{ __DEFAULT ->
(# ww1_s4AU, ghc-prim:GHC.Tuple.Prim.() #)
}
}
-- RHS size: {terms: 4, types: 1, coercions: 9, joins: 0/0}
BenchShort.benchShort33
:: tasty-1.4.3-5ff128a6e1ca080f4ba7000442aac93484033725a048c7bebd631c80dacde107:Test.Tasty.Core.TestTree
[GblId,
Unf=Unf{Src=<vanilla>, TopLvl=True,
Value=True, ConLike=True, WorkFree=True, Expandable=True,
Guidance=IF_ARGS [] 10 10}]
BenchShort.benchShort33
= tasty-1.4.3-5ff128a6e1ca080f4ba7000442aac93484033725a048c7bebd631c80dacde107:Test.Tasty.Core.SingleTest
@Benchmarkable
Test.Tasty.Bench.$fIsTestBenchmarkable
BenchShort.benchShort35
(BenchShort.benchShort34
`cast` (<Word64>_R
%<Many>_N ->_R Sym (ghc-prim:GHC.Types.N:IO[0] <()>_R)
; Sym (Test.Tasty.Bench.N:Benchmarkable[0])
:: (Word64
-> ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld
-> (# ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld, () #))
~R# Benchmarkable))
-- RHS size: {terms: 3, types: 2, coercions: 0, joins: 0/0}
BenchShort.benchShort32 :: [Benchmark]
[GblId,
Unf=Unf{Src=<vanilla>, TopLvl=True,
Value=True, ConLike=True, WorkFree=True, Expandable=True,
Guidance=IF_ARGS [] 10 10}]
BenchShort.benchShort32
= ghc-prim:GHC.Types.:
@Benchmark
BenchShort.benchShort33
(ghc-prim:GHC.Types.[] @Benchmark)
-- RHS size: {terms: 15, types: 12, coercions: 0, joins: 0/0}
BenchShort.benchShort9
:: Word64
-> ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld
-> (# ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld, () #)
[GblId,
Arity=2,
Str=<1!P(1L)><L>,
Cpr=1(, 1),
Unf=Unf{Src=StableSystem, TopLvl=True,
Value=True, ConLike=True, WorkFree=True, Expandable=True,
Guidance=ALWAYS_IF(arity=2,unsat_ok=True,boring_ok=False)
Tmpl= \ (eta2_i4ky [Occ=Once1] :: Word64)
(eta3_i4kA [Occ=Once1, OS=OneShot]
:: ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld) ->
BenchShort.benchShort10 find_index absurdlong eta2_i4ky eta3_i4kA}]
BenchShort.benchShort9
= \ (eta2_i4ky :: Word64)
(eta3_i4kA [OS=OneShot]
:: ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld) ->
case eta2_i4ky of { GHC.Word.W64# ww_s4BS ->
case BenchShort.$wbenchLoop find_index absurdlong ww_s4BS eta3_i4kA
of ww1_s4BX
{ __DEFAULT ->
(# ww1_s4BX, ghc-prim:GHC.Tuple.Prim.() #)
}
}
-- RHS size: {terms: 4, types: 1, coercions: 9, joins: 0/0}
BenchShort.benchShort13
:: tasty-1.4.3-5ff128a6e1ca080f4ba7000442aac93484033725a048c7bebd631c80dacde107:Test.Tasty.Core.TestTree
[GblId,
Unf=Unf{Src=<vanilla>, TopLvl=True,
Value=True, ConLike=True, WorkFree=True, Expandable=True,
Guidance=IF_ARGS [] 10 10}]
BenchShort.benchShort13
= tasty-1.4.3-5ff128a6e1ca080f4ba7000442aac93484033725a048c7bebd631c80dacde107:Test.Tasty.Core.SingleTest
@Benchmarkable
Test.Tasty.Bench.$fIsTestBenchmarkable
BenchShort.benchShort14
(BenchShort.benchShort9
`cast` (<Word64>_R
%<Many>_N ->_R Sym (ghc-prim:GHC.Types.N:IO[0] <()>_R)
; Sym (Test.Tasty.Bench.N:Benchmarkable[0])
:: (Word64
-> ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld
-> (# ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld, () #))
~R# Benchmarkable))
-- RHS size: {terms: 4, types: 1, coercions: 9, joins: 0/0}
BenchShort.benchShort8
:: tasty-1.4.3-5ff128a6e1ca080f4ba7000442aac93484033725a048c7bebd631c80dacde107:Test.Tasty.Core.TestTree
[GblId,
Unf=Unf{Src=<vanilla>, TopLvl=True,
Value=True, ConLike=True, WorkFree=True, Expandable=True,
Guidance=IF_ARGS [] 10 10}]
BenchShort.benchShort8
= tasty-1.4.3-5ff128a6e1ca080f4ba7000442aac93484033725a048c7bebd631c80dacde107:Test.Tasty.Core.SingleTest
@Benchmarkable
Test.Tasty.Bench.$fIsTestBenchmarkable
BenchShort.benchShort11
(BenchShort.benchShort9
`cast` (<Word64>_R
%<Many>_N ->_R Sym (ghc-prim:GHC.Types.N:IO[0] <()>_R)
; Sym (Test.Tasty.Bench.N:Benchmarkable[0])
:: (Word64
-> ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld
-> (# ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld, () #))
~R# Benchmarkable))
-- RHS size: {terms: 3, types: 2, coercions: 0, joins: 0/0}
BenchShort.benchShort7 :: [Benchmark]
[GblId,
Unf=Unf{Src=<vanilla>, TopLvl=True,
Value=True, ConLike=True, WorkFree=True, Expandable=True,
Guidance=IF_ARGS [] 10 10}]
BenchShort.benchShort7
= ghc-prim:GHC.Types.:
@Benchmark
BenchShort.benchShort8
(ghc-prim:GHC.Types.[] @Benchmark)
-- RHS size: {terms: 3, types: 1, coercions: 0, joins: 0/0}
BenchShort.benchShort6 :: [Benchmark]
[GblId,
Unf=Unf{Src=<vanilla>, TopLvl=True,
Value=True, ConLike=True, WorkFree=True, Expandable=True,
Guidance=IF_ARGS [] 10 10}]
BenchShort.benchShort6
= ghc-prim:GHC.Types.:
@Benchmark BenchShort.benchShort13 BenchShort.benchShort7
-- RHS size: {terms: 14, types: 12, coercions: 0, joins: 0/0}
BenchShort.benchShort38
:: Word64
-> ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld
-> (# ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld, () #)
[GblId,
Arity=2,
Str=<1!P(1L)><L>,
Cpr=1(, 1),
Unf=Unf{Src=StableSystem, TopLvl=True,
Value=True, ConLike=True, WorkFree=True, Expandable=True,
Guidance=ALWAYS_IF(arity=2,unsat_ok=True,boring_ok=False)
Tmpl= \ (eta2_i4ky [Occ=Once1] :: Word64)
(eta3_i4kA [Occ=Once1, OS=OneShot]
:: ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld) ->
BenchShort.benchShort10
BenchShort.benchShort_eta3 absurdlong eta2_i4ky eta3_i4kA}]
BenchShort.benchShort38
= \ (eta2_i4ky :: Word64)
(eta3_i4kA [OS=OneShot]
:: ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld) ->
case eta2_i4ky of { GHC.Word.W64# ww_s4Au ->
case BenchShort.benchShort_$s$wbenchLoop1
absurdlong ww_s4Au eta3_i4kA
of ww1_s4Az
{ __DEFAULT ->
(# ww1_s4Az, ghc-prim:GHC.Tuple.Prim.() #)
}
}
-- RHS size: {terms: 4, types: 1, coercions: 9, joins: 0/0}
BenchShort.benchShort37
:: tasty-1.4.3-5ff128a6e1ca080f4ba7000442aac93484033725a048c7bebd631c80dacde107:Test.Tasty.Core.TestTree
[GblId,
Unf=Unf{Src=<vanilla>, TopLvl=True,
Value=True, ConLike=True, WorkFree=True, Expandable=True,
Guidance=IF_ARGS [] 10 10}]
BenchShort.benchShort37
= tasty-1.4.3-5ff128a6e1ca080f4ba7000442aac93484033725a048c7bebd631c80dacde107:Test.Tasty.Core.SingleTest
@Benchmarkable
Test.Tasty.Bench.$fIsTestBenchmarkable
BenchShort.benchShort39
(BenchShort.benchShort38
`cast` (<Word64>_R
%<Many>_N ->_R Sym (ghc-prim:GHC.Types.N:IO[0] <()>_R)
; Sym (Test.Tasty.Bench.N:Benchmarkable[0])
:: (Word64
-> ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld
-> (# ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld, () #))
~R# Benchmarkable))
-- RHS size: {terms: 3, types: 1, coercions: 0, joins: 0/0}
BenchShort.benchShort31 :: [Benchmark]
[GblId,
Unf=Unf{Src=<vanilla>, TopLvl=True,
Value=True, ConLike=True, WorkFree=True, Expandable=True,
Guidance=IF_ARGS [] 10 10}]
BenchShort.benchShort31
= ghc-prim:GHC.Types.:
@Benchmark BenchShort.benchShort37 BenchShort.benchShort32
-- RHS size: {terms: 3, types: 1, coercions: 0, joins: 0/0}
BenchShort.benchShort30 :: [Benchmark]
[GblId,
Unf=Unf{Src=<vanilla>, TopLvl=True,
Value=True, ConLike=True, WorkFree=True, Expandable=True,
Guidance=IF_ARGS [] 10 10}]
BenchShort.benchShort30
= ghc-prim:GHC.Types.:
@Benchmark BenchShort.benchShort41 BenchShort.benchShort31
-- RHS size: {terms: 3, types: 0, coercions: 0, joins: 0/0}
BenchShort.benchShort29
:: tasty-1.4.3-5ff128a6e1ca080f4ba7000442aac93484033725a048c7bebd631c80dacde107:Test.Tasty.Core.TestTree
[GblId,
Unf=Unf{Src=<vanilla>, TopLvl=True,
Value=True, ConLike=True, WorkFree=True, Expandable=True,
Guidance=IF_ARGS [] 10 10}]
BenchShort.benchShort29
= tasty-1.4.3-5ff128a6e1ca080f4ba7000442aac93484033725a048c7bebd631c80dacde107:Test.Tasty.Core.TestGroup
BenchShort.benchShort45 BenchShort.benchShort30
Rec {
-- RHS size: {terms: 11, types: 9, coercions: 0, joins: 0/0}
$wgo_r4Gq :: [Int] -> (# #)
[GblId[StrictWorker([!])], Arity=1, Str=<1L>, Unf=OtherCon []]
$wgo_r4Gq
= \ (ds_s4zw :: [Int]) ->
case ds_s4zw of {
[] -> ghc-prim:GHC.Prim.(##);
: x_i48p xs_i48q ->
case x_i48p of { ghc-prim:GHC.Types.I# ipv_i48h ->
$wgo_r4Gq xs_i48q
}
}
end Rec }
Rec {
-- RHS size: {terms: 26, types: 22, coercions: 0, joins: 0/1}
BenchShort.benchShort_$s$wbenchLoop4 [Occ=LoopBreaker]
:: ShortByteString
-> ghc-prim:GHC.Prim.Word64#
-> ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld
-> ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld
[GblId, Arity=3, Str=<L><1L><L>, Unf=OtherCon []]
BenchShort.benchShort_$s$wbenchLoop4
= \ (x_s4Bb :: ShortByteString)
(ww_s4Be :: ghc-prim:GHC.Prim.Word64#)
(eta_s4Bg [OS=OneShot]
:: ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld) ->
case ww_s4Be of wild_X1 {
__DEFAULT ->
case ghc-prim:GHC.Prim.seq#
@[Int]
@ghc-prim:GHC.Prim.RealWorld
(let {
x1_s4vu [Dmd=SL] :: [Int]
[LclId]
x1_s4vu = BenchShort.benchShort_eta1 x_s4Bb } in
case $wgo_r4Gq x1_s4vu of { (# #) -> x1_s4vu })
eta_s4Bg
of
{ (# ipv_i4kO, ipv1_i4kP #) ->
BenchShort.benchShort_$s$wbenchLoop4
x_s4Bb (ghc-prim:GHC.Prim.subWord64# wild_X1 1#Word64) ipv_i4kO
};
0#Word64 -> eta_s4Bg
}
end Rec }
Rec {
-- RHS size: {terms: 28, types: 25, coercions: 0, joins: 0/1}
BenchShort.$wbenchLoop2 [InlPrag=[2], Occ=LoopBreaker]
:: (ShortByteString -> [Int])
-> ShortByteString
-> ghc-prim:GHC.Prim.Word64#
-> ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld
-> ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld
[GblId, Arity=4, Str=<L><L><1L><L>, Unf=OtherCon []]
BenchShort.$wbenchLoop2
= \ (f_s4Ba :: ShortByteString -> [Int])
(x_s4Bb :: ShortByteString)
(ww_s4Be :: ghc-prim:GHC.Prim.Word64#)
(eta_s4Bg [OS=OneShot]
:: ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld) ->
case ww_s4Be of wild_X1 {
__DEFAULT ->
case ghc-prim:GHC.Prim.seq#
@[Int]
@ghc-prim:GHC.Prim.RealWorld
(let {
x1_s4vu [Dmd=SL] :: [Int]
[LclId]
x1_s4vu = f_s4Ba x_s4Bb } in
case $wgo_r4Gq x1_s4vu of { (# #) -> x1_s4vu })
eta_s4Bg
of
{ (# ipv_i4kO, ipv1_i4kP #) ->
BenchShort.$wbenchLoop2
f_s4Ba
x_s4Bb
(ghc-prim:GHC.Prim.subWord64# wild_X1 1#Word64)
ipv_i4kO
};
0#Word64 -> eta_s4Bg
}
end Rec }
-- RHS size: {terms: 17, types: 16, coercions: 0, joins: 0/0}
BenchShort.benchShort24 [InlPrag=[2]]
:: (ShortByteString -> [Int])
-> ShortByteString
-> Word64
-> ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld
-> (# ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld, () #)
[GblId[StrictWorker([~, ~, !])],
Arity=4,
Str=<L><L><1!P(1L)><L>,
Cpr=1(, 1),
Unf=Unf{Src=StableSystem, TopLvl=True,
Value=True, ConLike=True, WorkFree=True, Expandable=True,
Guidance=ALWAYS_IF(arity=4,unsat_ok=True,boring_ok=False)
Tmpl= \ (f_s4Ba [Occ=Once1] :: ShortByteString -> [Int])
(x_s4Bb [Occ=Once1] :: ShortByteString)
(n2_s4Bc [Occ=Once1!] :: Word64)
(eta_s4Bg [Occ=Once1, OS=OneShot]
:: ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld) ->
case n2_s4Bc of { GHC.Word.W64# ww_s4Be [Occ=Once1] ->
case BenchShort.$wbenchLoop2 f_s4Ba x_s4Bb ww_s4Be eta_s4Bg
of ww1_s4Bj [Occ=Once1]
{ __DEFAULT ->
(# ww1_s4Bj, ghc-prim:GHC.Tuple.Prim.() #)
}
}}]
BenchShort.benchShort24
= \ (f_s4Ba :: ShortByteString -> [Int])
(x_s4Bb :: ShortByteString)
(n2_s4Bc :: Word64)
(eta_s4Bg [OS=OneShot]
:: ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld) ->
case n2_s4Bc of { GHC.Word.W64# ww_s4Be ->
case BenchShort.$wbenchLoop2 f_s4Ba x_s4Bb ww_s4Be eta_s4Bg
of ww1_s4Bj
{ __DEFAULT ->
(# ww1_s4Bj, ghc-prim:GHC.Tuple.Prim.() #)
}
}
-- RHS size: {terms: 14, types: 12, coercions: 0, joins: 0/0}
BenchShort.benchShort23
:: Word64
-> ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld
-> (# ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld, () #)
[GblId,
Arity=2,
Str=<1!P(1L)><L>,
Cpr=1(, 1),
Unf=Unf{Src=StableSystem, TopLvl=True,
Value=True, ConLike=True, WorkFree=True, Expandable=True,
Guidance=ALWAYS_IF(arity=2,unsat_ok=True,boring_ok=False)
Tmpl= \ (eta2_i4ky [Occ=Once1] :: Word64)
(eta3_i4kA [Occ=Once1, OS=OneShot]
:: ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld) ->
BenchShort.benchShort24
BenchShort.benchShort_eta1 absurdlong eta2_i4ky eta3_i4kA}]
BenchShort.benchShort23
= \ (eta2_i4ky :: Word64)
(eta3_i4kA [OS=OneShot]
:: ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld) ->
case eta2_i4ky of { GHC.Word.W64# ww_s4Be ->
case BenchShort.benchShort_$s$wbenchLoop4
absurdlong ww_s4Be eta3_i4kA
of ww1_s4Bj
{ __DEFAULT ->
(# ww1_s4Bj, ghc-prim:GHC.Tuple.Prim.() #)
}
}
-- RHS size: {terms: 4, types: 1, coercions: 9, joins: 0/0}
BenchShort.benchShort22
:: tasty-1.4.3-5ff128a6e1ca080f4ba7000442aac93484033725a048c7bebd631c80dacde107:Test.Tasty.Core.TestTree
[GblId,
Unf=Unf{Src=<vanilla>, TopLvl=True,
Value=True, ConLike=True, WorkFree=True, Expandable=True,
Guidance=IF_ARGS [] 10 10}]
BenchShort.benchShort22
= tasty-1.4.3-5ff128a6e1ca080f4ba7000442aac93484033725a048c7bebd631c80dacde107:Test.Tasty.Core.SingleTest
@Benchmarkable
Test.Tasty.Bench.$fIsTestBenchmarkable
BenchShort.benchShort25
(BenchShort.benchShort23
`cast` (<Word64>_R
%<Many>_N ->_R Sym (ghc-prim:GHC.Types.N:IO[0] <()>_R)
; Sym (Test.Tasty.Bench.N:Benchmarkable[0])
:: (Word64
-> ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld
-> (# ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld, () #))
~R# Benchmarkable))
Rec {
-- RHS size: {terms: 26, types: 22, coercions: 0, joins: 0/1}
BenchShort.benchShort_$s$wbenchLoop3 [Occ=LoopBreaker]
:: ShortByteString
-> ghc-prim:GHC.Prim.Word64#
-> ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld
-> ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld
[GblId, Arity=3, Str=<L><1L><L>, Unf=OtherCon []]
BenchShort.benchShort_$s$wbenchLoop3
= \ (x_s4BA :: ShortByteString)
(ww_s4BD :: ghc-prim:GHC.Prim.Word64#)
(eta_s4BF [OS=OneShot]
:: ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld) ->
case ww_s4BD of wild_X1 {
__DEFAULT ->
case ghc-prim:GHC.Prim.seq#
@[Int]
@ghc-prim:GHC.Prim.RealWorld
(let {
x1_s4vE [Dmd=SL] :: [Int]
[LclId]
x1_s4vE = BenchShort.benchShort_eta x_s4BA } in
case $wgo_r4Gq x1_s4vE of { (# #) -> x1_s4vE })
eta_s4BF
of
{ (# ipv_i4kO, ipv1_i4kP #) ->
BenchShort.benchShort_$s$wbenchLoop3
x_s4BA (ghc-prim:GHC.Prim.subWord64# wild_X1 1#Word64) ipv_i4kO
};
0#Word64 -> eta_s4BF
}
end Rec }
Rec {
-- RHS size: {terms: 28, types: 25, coercions: 0, joins: 0/1}
BenchShort.$wbenchLoop1 [InlPrag=[2], Occ=LoopBreaker]
:: (ShortByteString -> [Int])
-> ShortByteString
-> ghc-prim:GHC.Prim.Word64#
-> ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld
-> ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld
[GblId, Arity=4, Str=<L><L><1L><L>, Unf=OtherCon []]
BenchShort.$wbenchLoop1
= \ (f_s4Bz :: ShortByteString -> [Int])
(x_s4BA :: ShortByteString)
(ww_s4BD :: ghc-prim:GHC.Prim.Word64#)
(eta_s4BF [OS=OneShot]
:: ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld) ->
case ww_s4BD of wild_X1 {
__DEFAULT ->
case ghc-prim:GHC.Prim.seq#
@[Int]
@ghc-prim:GHC.Prim.RealWorld
(let {
x1_s4vE [Dmd=SL] :: [Int]
[LclId]
x1_s4vE = f_s4Bz x_s4BA } in
case $wgo_r4Gq x1_s4vE of { (# #) -> x1_s4vE })
eta_s4BF
of
{ (# ipv_i4kO, ipv1_i4kP #) ->
BenchShort.$wbenchLoop1
f_s4Bz
x_s4BA
(ghc-prim:GHC.Prim.subWord64# wild_X1 1#Word64)
ipv_i4kO
};
0#Word64 -> eta_s4BF
}
end Rec }
-- RHS size: {terms: 17, types: 16, coercions: 0, joins: 0/0}
BenchShort.benchShort19 [InlPrag=[2]]
:: (ShortByteString -> [Int])
-> ShortByteString
-> Word64
-> ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld
-> (# ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld, () #)
[GblId[StrictWorker([~, ~, !])],
Arity=4,
Str=<L><L><1!P(1L)><L>,
Cpr=1(, 1),
Unf=Unf{Src=StableSystem, TopLvl=True,
Value=True, ConLike=True, WorkFree=True, Expandable=True,
Guidance=ALWAYS_IF(arity=4,unsat_ok=True,boring_ok=False)
Tmpl= \ (f_s4Bz [Occ=Once1] :: ShortByteString -> [Int])
(x_s4BA [Occ=Once1] :: ShortByteString)
(n2_s4BB [Occ=Once1!] :: Word64)
(eta_s4BF [Occ=Once1, OS=OneShot]
:: ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld) ->
case n2_s4BB of { GHC.Word.W64# ww_s4BD [Occ=Once1] ->
case BenchShort.$wbenchLoop1 f_s4Bz x_s4BA ww_s4BD eta_s4BF
of ww1_s4BI [Occ=Once1]
{ __DEFAULT ->
(# ww1_s4BI, ghc-prim:GHC.Tuple.Prim.() #)
}
}}]
BenchShort.benchShort19
= \ (f_s4Bz :: ShortByteString -> [Int])
(x_s4BA :: ShortByteString)
(n2_s4BB :: Word64)
(eta_s4BF [OS=OneShot]
:: ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld) ->
case n2_s4BB of { GHC.Word.W64# ww_s4BD ->
case BenchShort.$wbenchLoop1 f_s4Bz x_s4BA ww_s4BD eta_s4BF
of ww1_s4BI
{ __DEFAULT ->
(# ww1_s4BI, ghc-prim:GHC.Tuple.Prim.() #)
}
}
-- RHS size: {terms: 14, types: 12, coercions: 0, joins: 0/0}
BenchShort.benchShort17
:: Word64
-> ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld
-> (# ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld, () #)
[GblId,
Arity=2,
Str=<1!P(1L)><L>,
Cpr=1(, 1),
Unf=Unf{Src=StableSystem, TopLvl=True,
Value=True, ConLike=True, WorkFree=True, Expandable=True,
Guidance=ALWAYS_IF(arity=2,unsat_ok=True,boring_ok=False)
Tmpl= \ (eta2_i4ky [Occ=Once1] :: Word64)
(eta3_i4kA [Occ=Once1, OS=OneShot]
:: ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld) ->
BenchShort.benchShort19
BenchShort.benchShort_eta absurdlong eta2_i4ky eta3_i4kA}]
BenchShort.benchShort17
= \ (eta2_i4ky :: Word64)
(eta3_i4kA [OS=OneShot]
:: ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld) ->
case eta2_i4ky of { GHC.Word.W64# ww_s4BD ->
case BenchShort.benchShort_$s$wbenchLoop3
absurdlong ww_s4BD eta3_i4kA
of ww1_s4BI
{ __DEFAULT ->
(# ww1_s4BI, ghc-prim:GHC.Tuple.Prim.() #)
}
}
-- RHS size: {terms: 4, types: 1, coercions: 9, joins: 0/0}
BenchShort.benchShort16
:: tasty-1.4.3-5ff128a6e1ca080f4ba7000442aac93484033725a048c7bebd631c80dacde107:Test.Tasty.Core.TestTree
[GblId,
Unf=Unf{Src=<vanilla>, TopLvl=True,
Value=True, ConLike=True, WorkFree=True, Expandable=True,
Guidance=IF_ARGS [] 10 10}]
BenchShort.benchShort16
= tasty-1.4.3-5ff128a6e1ca080f4ba7000442aac93484033725a048c7bebd631c80dacde107:Test.Tasty.Core.SingleTest
@Benchmarkable
Test.Tasty.Bench.$fIsTestBenchmarkable
BenchShort.benchShort20
(BenchShort.benchShort17
`cast` (<Word64>_R
%<Many>_N ->_R Sym (ghc-prim:GHC.Types.N:IO[0] <()>_R)
; Sym (Test.Tasty.Bench.N:Benchmarkable[0])
:: (Word64
-> ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld
-> (# ghc-prim:GHC.Prim.State# ghc-prim:GHC.Prim.RealWorld, () #))
~R# Benchmarkable))
-- RHS size: {terms: 3, types: 1, coercions: 0, joins: 0/0}
BenchShort.benchShort5 :: [Benchmark]
[GblId,
Unf=Unf{Src=<vanilla>, TopLvl=True,
Value=True, ConLike=True, WorkFree=True, Expandable=True,
Guidance=IF_ARGS [] 10 10}]
BenchShort.benchShort5
= ghc-prim:GHC.Types.:
@Benchmark BenchShort.benchShort16 BenchShort.benchShort6
-- RHS size: {terms: 3, types: 1, coercions: 0, joins: 0/0}
BenchShort.benchShort4 :: [Benchmark]
[GblId,
Unf=Unf{Src=<vanilla>, TopLvl=True,
Value=True, ConLike=True, WorkFree=True, Expandable=True,
Guidance=IF_ARGS [] 10 10}]
BenchShort.benchShort4
= ghc-prim:GHC.Types.:
@Benchmark BenchShort.benchShort22 BenchShort.benchShort5
-- RHS size: {terms: 3, types: 0, coercions: 0, joins: 0/0}
BenchShort.benchShort3
:: tasty-1.4.3-5ff128a6e1ca080f4ba7000442aac93484033725a048c7bebd631c80dacde107:Test.Tasty.Core.TestTree
[GblId,
Unf=Unf{Src=<vanilla>, TopLvl=True,
Value=True, ConLike=True, WorkFree=True, Expandable=True,
Guidance=IF_ARGS [] 10 10}]
BenchShort.benchShort3
= tasty-1.4.3-5ff128a6e1ca080f4ba7000442aac93484033725a048c7bebd631c80dacde107:Test.Tasty.Core.TestGroup
BenchShort.benchShort27 BenchShort.benchShort4
-- RHS size: {terms: 3, types: 2, coercions: 0, joins: 0/0}
BenchShort.benchShort2 :: [Benchmark]
[GblId,
Unf=Unf{Src=<vanilla>, TopLvl=True,
Value=True, ConLike=True, WorkFree=True, Expandable=True,
Guidance=IF_ARGS [] 10 10}]
BenchShort.benchShort2
= ghc-prim:GHC.Types.:
@Benchmark
BenchShort.benchShort3
(ghc-prim:GHC.Types.[] @Benchmark)
-- RHS size: {terms: 3, types: 1, coercions: 0, joins: 0/0}
BenchShort.benchShort1 :: [Benchmark]
[GblId,
Unf=Unf{Src=<vanilla>, TopLvl=True,
Value=True, ConLike=True, WorkFree=True, Expandable=True,
Guidance=IF_ARGS [] 10 10}]
BenchShort.benchShort1
= ghc-prim:GHC.Types.:
@Benchmark BenchShort.benchShort29 BenchShort.benchShort2
-- RHS size: {terms: 3, types: 0, coercions: 0, joins: 0/0}
benchShort :: Benchmark
[GblId,
Unf=Unf{Src=<vanilla>, TopLvl=True,
Value=True, ConLike=True, WorkFree=True, Expandable=True,
Guidance=IF_ARGS [] 10 10}]
benchShort
= tasty-1.4.3-5ff128a6e1ca080f4ba7000442aac93484033725a048c7bebd631c80dacde107:Test.Tasty.Core.TestGroup
BenchShort.benchShort47 BenchShort.benchShort1
-- RHS size: {terms: 1, types: 0, coercions: 0, joins: 0/0}
BenchShort.$trModule2 :: ghc-prim:GHC.Prim.Addr#
[GblId,
Unf=Unf{Src=<vanilla>, TopLvl=True,
Value=True, ConLike=True, WorkFree=True, Expandable=True,
Guidance=IF_ARGS [] 40 0}]
BenchShort.$trModule2 = "BenchShort"#
-- RHS size: {terms: 2, types: 0, coercions: 0, joins: 0/0}
BenchShort.$trModule1 :: ghc-prim:GHC.Types.TrName
[GblId,
Unf=Unf{Src=<vanilla>, TopLvl=True,
Value=True, ConLike=True, WorkFree=True, Expandable=True,
Guidance=IF_ARGS [] 10 10}]
BenchShort.$trModule1
= ghc-prim:GHC.Types.TrNameS BenchShort.$trModule2
-- RHS size: {terms: 1, types: 0, coercions: 0, joins: 0/0}
BenchShort.$trModule4 :: ghc-prim:GHC.Prim.Addr#
[GblId,
Unf=Unf{Src=<vanilla>, TopLvl=True,
Value=True, ConLike=True, WorkFree=True, Expandable=True,
Guidance=IF_ARGS [] 20 0}]
BenchShort.$trModule4 = "main"#
-- RHS size: {terms: 2, types: 0, coercions: 0, joins: 0/0}
BenchShort.$trModule3 :: ghc-prim:GHC.Types.TrName
[GblId,
Unf=Unf{Src=<vanilla>, TopLvl=True,
Value=True, ConLike=True, WorkFree=True, Expandable=True,
Guidance=IF_ARGS [] 10 10}]
BenchShort.$trModule3
= ghc-prim:GHC.Types.TrNameS BenchShort.$trModule4
-- RHS size: {terms: 3, types: 0, coercions: 0, joins: 0/0}
BenchShort.$trModule :: ghc-prim:GHC.Types.Module
[GblId,
Unf=Unf{Src=<vanilla>, TopLvl=True,
Value=True, ConLike=True, WorkFree=True, Expandable=True,
Guidance=IF_ARGS [] 10 10}]
BenchShort.$trModule
= ghc-prim:GHC.Types.Module
BenchShort.$trModule3 BenchShort.$trModule1
------ Local rules for imported ids --------
"SC:$wbenchLoop0" [2]
forall.
BenchShort.$wbenchLoop BenchShort.benchShort_eta4
= BenchShort.benchShort_$s$wbenchLoop2
"SC:$wbenchLoop1" [2]
forall.
BenchShort.$wbenchLoop BenchShort.benchShort_eta3
= BenchShort.benchShort_$s$wbenchLoop1
"SC:$wbenchLoop2" [2]
forall.
BenchShort.$wbenchLoop BenchShort.benchShort_eta2
= BenchShort.benchShort_$s$wbenchLoop
"SC:$wbenchLoop0" [2]
forall.
BenchShort.$wbenchLoop2 BenchShort.benchShort_eta1
= BenchShort.benchShort_$s$wbenchLoop4
"SC:$wbenchLoop0" [2]
forall.
BenchShort.$wbenchLoop1 BenchShort.benchShort_eta
= BenchShort.benchShort_$s$wbenchLoop3
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment