==================== Tidy Core ==================== Result size of Tidy Core = {terms: 7,096, types: 13,176, coercions: 213, joins: 42/168} -- RHS size: {terms: 21, types: 15, coercions: 0, joins: 0/0} singleton = \ @ k @ v $dHashable k1 v1 -> case v1 of v2 { __DEFAULT -> case hash $dHashable k1 of { I# x# -> case k1 of dt { __DEFAULT -> Leaf (int2Word# x#) dt v2 } } } -- RHS size: {terms: 14, types: 14, coercions: 0, joins: 0/0} $winsert = \ @ k @ v w w1 w2 w3 -> case w2 of v1 { __DEFAULT -> $winsert w w1 v1 w3 } -- RHS size: {terms: 12, types: 15, coercions: 0, joins: 0/0} insert = \ @ k @ v _ w1 w2 w3 w4 -> $winsert w1 w2 w3 w4 -- RHS size: {terms: 32, types: 35, coercions: 0, joins: 0/0} $walter = \ @ k @ v w w1 w2 w3 -> case w1 (case $wlookup# w w2 w3 of { (#_|#) ds1 -> Nothing; (#|_#) a -> Just a }) of { Nothing -> $wdelete w w2 w3; Just v1 -> case v1 of v2 { __DEFAULT -> $winsert w w2 v2 w3 } } -- RHS size: {terms: 12, types: 18, coercions: 0, joins: 0/0} alter = \ @ k @ v _ w1 w2 w3 w4 -> $walter w1 w2 w3 w4 -- RHS size: {terms: 14, types: 19, coercions: 0, joins: 0/0} $wupdate = \ @ k @ a w w1 w2 w3 -> $walter w (\ ds -> $fMonadMaybe_$c>>= ds w1) w2 w3 -- RHS size: {terms: 12, types: 17, coercions: 0, joins: 0/0} update = \ @ k @ a _ w1 w2 w3 w4 -> $wupdate w1 w2 w3 w4 -- RHS size: {terms: 159, types: 201, coercions: 0, joins: 3/5} $wdifferenceWith = \ @ k @ v @ w w1 w2 w3 w4 -> let { f = \ m k1 v1 -> case $wlookup# w1 k1 w4 of { (#_|#) ds1 -> case v1 of v2 { __DEFAULT -> $winsert w1 k1 v2 m }; (#|_#) a -> case w2 v1 a of { Nothing -> m; Just x -> case x of v2 { __DEFAULT -> $winsert w1 k1 v2 m } } } } in letrec { go1 = \ z ds -> case ds of { Empty -> z; BitmapIndexed dt dt1 -> joinrec { $s$wgo2 sc sc1 sc2 sc3 = case >=# sc1 sc2 of { __DEFAULT -> case indexSmallArray# sc3 sc1 of { (# ipv #) -> jump $s$wgo2 (go1 sc ipv) (+# sc1 1#) sc2 sc3 }; 1# -> sc }; } in jump $s$wgo2 z 0# (sizeofSmallArray# dt1) dt1; Leaf dt dt1 dt2 -> f z dt1 dt2; Full dt -> joinrec { $s$wgo2 sc sc1 sc2 sc3 = case >=# sc1 sc2 of { __DEFAULT -> case indexSmallArray# sc3 sc1 of { (# ipv #) -> jump $s$wgo2 (go1 sc ipv) (+# sc1 1#) sc2 sc3 }; 1# -> sc }; } in jump $s$wgo2 z 0# (sizeofSmallArray# dt) dt; Collision dt dt1 -> joinrec { $s$wgo2 sc sc1 sc2 sc3 = case >=# sc1 sc2 of { __DEFAULT -> case indexSmallArray# sc3 sc1 of { (# ipv #) -> case ipv of { L k1 v1 -> jump $s$wgo2 (f sc k1 v1) (+# sc1 1#) sc2 sc3 } }; 1# -> sc }; } in jump $s$wgo2 z 0# (sizeofSmallArray# dt1) dt1 }; } in go1 Empty w3 -- RHS size: {terms: 13, types: 23, coercions: 0, joins: 0/0} differenceWith = \ @ k @ v @ w _ w2 w3 w4 w5 -> $wdifferenceWith w2 w3 w4 w5 -- RHS size: {terms: 148, types: 196, coercions: 0, joins: 3/5} $wintersectionWith = \ @ k @ v1 @ v2 @ v3 w w1 w2 w3 -> let { f = \ m k1 v -> case $wlookup# w k1 w3 of { (#_|#) ds1 -> m; (#|_#) a -> case w1 v a of v4 { __DEFAULT -> $winsert w k1 v4 m } } } in letrec { go1 = \ z ds -> case ds of { Empty -> z; BitmapIndexed dt dt1 -> joinrec { $s$wgo2 sc sc1 sc2 sc3 = case >=# sc1 sc2 of { __DEFAULT -> case indexSmallArray# sc3 sc1 of { (# ipv #) -> jump $s$wgo2 (go1 sc ipv) (+# sc1 1#) sc2 sc3 }; 1# -> sc }; } in jump $s$wgo2 z 0# (sizeofSmallArray# dt1) dt1; Leaf dt dt1 dt2 -> f z dt1 dt2; Full dt -> joinrec { $s$wgo2 sc sc1 sc2 sc3 = case >=# sc1 sc2 of { __DEFAULT -> case indexSmallArray# sc3 sc1 of { (# ipv #) -> jump $s$wgo2 (go1 sc ipv) (+# sc1 1#) sc2 sc3 }; 1# -> sc }; } in jump $s$wgo2 z 0# (sizeofSmallArray# dt) dt; Collision dt dt1 -> joinrec { $s$wgo2 sc sc1 sc2 sc3 = case >=# sc1 sc2 of { __DEFAULT -> case indexSmallArray# sc3 sc1 of { (# ipv #) -> case ipv of { L k1 v4 -> jump $s$wgo2 (f sc k1 v4) (+# sc1 1#) sc2 sc3 } }; 1# -> sc }; } in jump $s$wgo2 z 0# (sizeofSmallArray# dt1) dt1 }; } in go1 Empty w2 -- RHS size: {terms: 14, types: 25, coercions: 0, joins: 0/0} intersectionWith = \ @ k @ v1 @ v2 @ v3 _ w1 w2 w3 w4 -> $wintersectionWith w1 w2 w3 w4 -- RHS size: {terms: 149, types: 197, coercions: 0, joins: 3/5} $wintersectionWithKey = \ @ k @ v1 @ v2 @ v3 w w1 w2 w3 -> let { f = \ m k1 v -> case $wlookup# w k1 w3 of { (#_|#) ds1 -> m; (#|_#) a -> case w1 k1 v a of v4 { __DEFAULT -> $winsert w k1 v4 m } } } in letrec { go1 = \ z ds -> case ds of { Empty -> z; BitmapIndexed dt dt1 -> joinrec { $s$wgo2 sc sc1 sc2 sc3 = case >=# sc1 sc2 of { __DEFAULT -> case indexSmallArray# sc3 sc1 of { (# ipv #) -> jump $s$wgo2 (go1 sc ipv) (+# sc1 1#) sc2 sc3 }; 1# -> sc }; } in jump $s$wgo2 z 0# (sizeofSmallArray# dt1) dt1; Leaf dt dt1 dt2 -> f z dt1 dt2; Full dt -> joinrec { $s$wgo2 sc sc1 sc2 sc3 = case >=# sc1 sc2 of { __DEFAULT -> case indexSmallArray# sc3 sc1 of { (# ipv #) -> jump $s$wgo2 (go1 sc ipv) (+# sc1 1#) sc2 sc3 }; 1# -> sc }; } in jump $s$wgo2 z 0# (sizeofSmallArray# dt) dt; Collision dt dt1 -> joinrec { $s$wgo2 sc sc1 sc2 sc3 = case >=# sc1 sc2 of { __DEFAULT -> case indexSmallArray# sc3 sc1 of { (# ipv #) -> case ipv of { L k1 v4 -> jump $s$wgo2 (f sc k1 v4) (+# sc1 1#) sc2 sc3 } }; 1# -> sc }; } in jump $s$wgo2 z 0# (sizeofSmallArray# dt1) dt1 }; } in go1 Empty w2 -- RHS size: {terms: 14, types: 26, coercions: 0, joins: 0/0} intersectionWithKey = \ @ k @ v1 @ v2 @ v3 _ w1 w2 w3 w4 -> $wintersectionWithKey w1 w2 w3 w4 -- RHS size: {terms: 1, types: 0, coercions: 0, joins: 0/0} lvl = "error"# -- RHS size: {terms: 2, types: 0, coercions: 0, joins: 0/0} lvl1 = unpackCString# lvl -- RHS size: {terms: 1, types: 0, coercions: 0, joins: 0/0} $trModule4 = "unordered-containers-0.2.15.0-inplace"# -- RHS size: {terms: 2, types: 0, coercions: 0, joins: 0/0} lvl2 = unpackCString# $trModule4 -- RHS size: {terms: 1, types: 0, coercions: 0, joins: 0/0} $trModule2 = "Data.HashMap.Internal.Strict"# -- RHS size: {terms: 2, types: 0, coercions: 0, joins: 0/0} lvl3 = unpackCString# $trModule2 -- RHS size: {terms: 1, types: 0, coercions: 0, joins: 0/0} lvl4 = "./Data/HashMap/Internal/Strict.hs"# -- RHS size: {terms: 2, types: 0, coercions: 0, joins: 0/0} lvl5 = unpackCString# lvl4 -- RHS size: {terms: 2, types: 0, coercions: 0, joins: 0/0} lvl6 = I# 329# -- RHS size: {terms: 2, types: 0, coercions: 0, joins: 0/0} lvl7 = I# 15# -- RHS size: {terms: 2, types: 0, coercions: 0, joins: 0/0} lvl8 = I# 74# -- RHS size: {terms: 8, types: 0, coercions: 0, joins: 0/0} lvl9 = SrcLoc lvl2 lvl3 lvl5 lvl6 lvl7 lvl6 lvl8 -- RHS size: {terms: 4, types: 0, coercions: 0, joins: 0/0} lvl10 = PushCallStack lvl1 lvl9 EmptyCallStack -- RHS size: {terms: 1, types: 0, coercions: 0, joins: 0/0} lvl11 = "Data.HashMap.alterF internal error: hit test_bottom"# -- RHS size: {terms: 5, types: 4, coercions: 4, joins: 0/0} test_bottom = \ @ a -> error (lvl10 `cast` ) (unpackCString# lvl11) -- RHS size: {terms: 2, types: 0, coercions: 0, joins: 0/0} loc = I# 332# -- RHS size: {terms: 2, types: 0, coercions: 0, joins: 0/0} loc1 = I# 12# -- RHS size: {terms: 2, types: 0, coercions: 0, joins: 0/0} loc2 = I# 66# -- RHS size: {terms: 8, types: 0, coercions: 0, joins: 0/0} $dIP = SrcLoc lvl2 lvl3 lvl5 loc loc1 loc loc2 -- RHS size: {terms: 4, types: 0, coercions: 0, joins: 0/0} $dIP1 = PushCallStack lvl1 $dIP EmptyCallStack -- RHS size: {terms: 1, types: 0, coercions: 0, joins: 0/0} lvl12 = "Data.HashMap.alterF internal error: hit bogus#"# -- RHS size: {terms: 2, types: 0, coercions: 0, joins: 0/0} lvl13 = unpackCString# lvl12 -- RHS size: {terms: 5, types: 12, coercions: 4, joins: 0/0} bogus# = \ @ a _ -> error ($dIP1 `cast` ) lvl13 -- RHS size: {terms: 2, types: 0, coercions: 0, joins: 0/0} lvl14 = I# 335# -- RHS size: {terms: 2, types: 0, coercions: 0, joins: 0/0} lvl15 = I# 20# -- RHS size: {terms: 2, types: 0, coercions: 0, joins: 0/0} lvl16 = I# 81# -- RHS size: {terms: 8, types: 0, coercions: 0, joins: 0/0} lvl17 = SrcLoc lvl2 lvl3 lvl5 lvl14 lvl15 lvl14 lvl16 -- RHS size: {terms: 4, types: 0, coercions: 0, joins: 0/0} lvl18 = PushCallStack lvl1 lvl17 EmptyCallStack -- RHS size: {terms: 1, types: 0, coercions: 0, joins: 0/0} lvl19 = "Data.HashMap.alterF internal error: impossible adjust"# -- RHS size: {terms: 5, types: 4, coercions: 4, joins: 0/0} impossibleAdjust = \ @ a -> error (lvl18 `cast` ) (unpackCString# lvl19) -- RHS size: {terms: 74, types: 93, coercions: 0, joins: 0/1} $walterFEager = \ @ f @ k @ v w w1 w2 w3 w4 -> case hash w1 w3 of { I# x# -> let { h = int2Word# x# } in case $wlookupRecordCollision# ($p1Hashable w1) h w3 w4 of { (#_|#) ds1 -> fmap w (\ fres -> case fres of { Nothing -> w4; Just v' -> $winsertNewKey h w3 v' w4 }) (w2 Nothing); (#|_#) ds1 -> case ds1 of { (# a, i #) -> fmap w (\ fres -> case fres of { Nothing -> $wdeleteKeyExists i h w3 w4; Just v' -> case v' of v'1 { __DEFAULT -> case reallyUnsafePtrEquality# a v'1 of { __DEFAULT -> $winsertKeyExists i h w3 v'1 w4; 1# -> w4 } } }) (w2 (Just a)) } } } -- RHS size: {terms: 28, types: 48, coercions: 0, joins: 1/1} $wfromList = \ @ k @ v w w1 -> joinrec { go1 ds eta = case ds of { [] -> eta; : y ys -> case y of { (k1, v1) -> case v1 of v2 { __DEFAULT -> jump go1 ys ($wunsafeInsert w k1 v2 eta) } } }; } in jump go1 w1 Empty -- RHS size: {terms: 8, types: 14, coercions: 0, joins: 0/0} fromList = \ @ k @ v _ w1 w2 -> $wfromList w1 w2 -- RHS size: {terms: 95, types: 185, coercions: 0, joins: 2/2} $wupdateWith = \ @ k @ v w w1 w2 ww -> join { exit ww1 ww2 k1 y = case w1 y of v' { __DEFAULT -> case runRW# (\ s1 -> case thawSmallArray# ww1 0# (sizeofSmallArray# ww1) s1 of { (# ipv, ipv1 #) -> case writeSmallArray# ipv1 ww2 (L k1 v') ipv of s' { __DEFAULT -> case unsafeFreezeSmallArray# ipv1 s' of { (# ipv2, ipv3 #) -> (# ipv2, Array ipv3 #) } } }) of { (# ipv, ipv1 #) -> ipv1 } } } in joinrec { $wgo w3 ww1 ww2 ww3 = case w3 of k1 { __DEFAULT -> case >=# ww2 ww3 of { __DEFAULT -> case indexSmallArray# ww1 ww2 of { (# ipv #) -> case ipv of { L kx y -> case == w k1 kx of { False -> jump $wgo k1 ww1 (+# ww2 1#) ww3; True -> jump exit ww1 ww2 k1 y } } }; 1# -> Array ww1 } }; } in jump $wgo w2 ww 0# (sizeofSmallArray# ww) -- RHS size: {terms: 144, types: 305, coercions: 0, joins: 2/2} $wupdateOrSnocWithKey = \ @ k @ v w w1 w2 w3 ww -> join { exit w4 ww1 ww2 k1 y = case w1 k1 w4 y of v' { __DEFAULT -> case runRW# (\ s1 -> case thawSmallArray# ww1 0# (sizeofSmallArray# ww1) s1 of { (# ipv, ipv1 #) -> case writeSmallArray# ipv1 ww2 (L k1 v') ipv of s' { __DEFAULT -> case unsafeFreezeSmallArray# ipv1 s' of { (# ipv2, ipv3 #) -> (# ipv2, Array ipv3 #) } } }) of { (# ipv, ipv1 #) -> ipv1 } } } in joinrec { $wgo w4 w5 ww1 ww2 ww3 = case w4 of k1 { __DEFAULT -> case >=# ww2 ww3 of { __DEFAULT -> case indexSmallArray# ww1 ww2 of { (# ipv #) -> case ipv of { L kx y -> case == w k1 kx of { False -> jump $wgo k1 w5 ww1 (+# ww2 1#) ww3; True -> jump exit w5 ww1 ww2 k1 y } } }; 1# -> case runRW# (\ s1 -> case newSmallArray# (+# ww3 1#) undefinedElem s1 of { (# ipv, ipv1 #) -> case copySmallArray# ww1 0# ipv1 0# ww3 ipv of s2 { __DEFAULT -> case w5 of v1 { __DEFAULT -> case writeSmallArray# ipv1 ww3 (L k1 v1) s2 of s' { __DEFAULT -> case unsafeFreezeSmallArray# ipv1 s' of { (# ipv2, ipv3 #) -> (# ipv2, Array ipv3 #) } } } } }) of { (# ipv, ipv1 #) -> ipv1 } } }; } in jump $wgo w2 w3 ww 0# (sizeofSmallArray# ww) -- RHS size: {terms: 16, types: 26, coercions: 0, joins: 0/0} updateOrSnocWithKey = \ @ k @ v w w1 w2 w3 w4 -> case w4 of { Array ww1 -> $wupdateOrSnocWithKey w w1 w2 w3 ww1 } -- RHS size: {terms: 14, types: 47, coercions: 0, joins: 0/0} lvl20 = \ @ v2 @ k @ s mary s1 -> case unsafeFreezeSmallArray# mary s1 of { (# ipv2, ipv3 #) -> (# ipv2, Array ipv3 #) } -- RHS size: {terms: 14, types: 47, coercions: 0, joins: 0/0} lvl21 = \ @ v2 @ k @ s mary s1 -> case unsafeFreezeSmallArray# mary s1 of { (# ipv2, ipv3 #) -> (# ipv2, Array ipv3 #) } -- RHS size: {terms: 267, types: 591, coercions: 197, joins: 0/11} traverseWithKey = \ @ f @ k @ v1 @ v2 $dApplicative eta eta1 -> let { lvl26 = pure $dApplicative Empty } in let { lvl27 = $p1Applicative $dApplicative } in let { lvl28 = pure $dApplicative (lvl21 `cast` ) } in let { lvl29 = pure $dApplicative (lvl20 `cast` ) } in letrec { go = \ ds -> case ds of { Empty -> lvl26; BitmapIndexed dt dt1 -> fmap lvl27 (\ dt2 -> case dt2 of { Array dt4 -> BitmapIndexed dt dt4 }) (let { len = sizeofSmallArray# dt1 } in fmap lvl27 (\ ds1 -> case runRW# (\ s1 -> case newSmallArray# len undefinedElem s1 of { (# ipv1, ipv2 #) -> (((ds1 `cast` ) ipv2) `cast` ) ipv1 }) of { (# ipv1, ipv2 #) -> ipv2 }) (letrec { $wgo = \ ww -> case ==# ww len of { __DEFAULT -> case indexSmallArray# dt1 ww of { (# ipv2 #) -> liftA2 $dApplicative ((\ b1 ds2 @ s eta2 eta3 -> case b1 of b2 { __DEFAULT -> case writeSmallArray# eta2 ww b2 eta3 of s' { __DEFAULT -> (((ds2 `cast` ) eta2) `cast` ) s' } }) `cast` ) (go ipv2) ($wgo (+# ww 1#)) }; 1# -> lvl29 }; } in $wgo 0#)); Leaf dt dt1 dt2 -> fmap lvl27 (\ v -> case v of v4 { __DEFAULT -> Leaf dt dt1 v4 }) (eta dt1 dt2); Full dt -> fmap lvl27 $WFull (let { len = sizeofSmallArray# dt } in fmap lvl27 (\ ds1 -> case runRW# (\ s1 -> case newSmallArray# len undefinedElem s1 of { (# ipv1, ipv2 #) -> (((ds1 `cast` ) ipv2) `cast` ) ipv1 }) of { (# ipv1, ipv2 #) -> ipv2 }) (letrec { $wgo = \ ww -> case ==# ww len of { __DEFAULT -> case indexSmallArray# dt ww of { (# ipv2 #) -> liftA2 $dApplicative ((\ b1 ds2 @ s eta2 eta3 -> case b1 of b2 { __DEFAULT -> case writeSmallArray# eta2 ww b2 eta3 of s' { __DEFAULT -> (((ds2 `cast` ) eta2) `cast` ) s' } }) `cast` ) (go ipv2) ($wgo (+# ww 1#)) }; 1# -> lvl29 }; } in $wgo 0#)); Collision dt dt1 -> fmap lvl27 (\ dt2 -> case dt2 of { Array dt4 -> Collision dt dt4 }) (let { len = sizeofSmallArray# dt1 } in fmap lvl27 (\ ds1 -> case runRW# (\ s1 -> case newSmallArray# len undefinedElem s1 of { (# ipv1, ipv2 #) -> (((ds1 `cast` ) ipv2) `cast` ) ipv1 }) of { (# ipv1, ipv2 #) -> ipv2 }) (letrec { $wgo = \ ww -> case ==# ww len of { __DEFAULT -> case indexSmallArray# dt1 ww of { (# ipv2 #) -> liftA2 $dApplicative ((\ b1 ds2 @ s eta2 eta3 -> case b1 of b2 { L ipv ipv1 -> case writeSmallArray# eta2 ww b2 eta3 of s' { __DEFAULT -> (((ds2 `cast` ) eta2) `cast` ) s' } }) `cast` ) (case ipv2 of { L k1 v -> fmap lvl27 (\ ds2 -> case ds2 of vx { __DEFAULT -> L k1 vx }) (eta k1 v) }) ($wgo (+# ww 1#)) }; 1# -> lvl28 }; } in $wgo 0#)) }; } in go eta1 -- RHS size: {terms: 341, types: 645, coercions: 0, joins: 0/6} mapMaybeWithKey = \ @ k @ v1 @ v2 f eta -> letrec { $wfilterA = \ ww ww1 -> case runRW# (\ s1 -> let { ipv = sizeofSmallArray# ww } in case newSmallArray# ipv undefinedElem s1 of { (# ipv1, ipv2 #) -> $wstep ww ipv2 ww1 0# 0# 1## ipv ipv1 }) of { (# ipv1, ipv2 #) -> ipv2 }; go1 = \ ds -> case ds of { Empty -> Empty; BitmapIndexed dt dt1 -> $wfilterA dt1 dt; Leaf dt dt1 dt2 -> case f dt1 dt2 of { Nothing -> Empty; Just v' -> case v' of v { __DEFAULT -> Leaf dt dt1 v } }; Full dt -> $wfilterA dt 4294967295##; Collision dt dt1 -> case runRW# (\ s1 -> let { n = sizeofSmallArray# dt1 } in case newSmallArray# n undefinedElem s1 of { (# ipv, ipv1 #) -> letrec { $wstep1 = \ @ s ww ww1 ww2 ww3 ww4 w -> case >=# ww2 ww4 of { __DEFAULT -> case indexSmallArray# ww ww2 of { (# ipv3 #) -> case ipv3 of { L ipv4 ipv5 -> case f ipv4 ipv5 of { Nothing -> $wstep1 ww ww1 (+# ww2 1#) ww3 ww4 w; Just v' -> case writeSmallArray# ww1 ww3 (L ipv4 v') w of s' { __DEFAULT -> $wstep1 ww ww1 (+# ww2 1#) (+# ww3 1#) ww4 s' } } } }; 1# -> case ww3 of ds2 { __DEFAULT -> case ==# ww2 ds2 of { __DEFAULT -> case cloneSmallMutableArray# ww1 0# ds2 w of { (# ipv3, ipv4 #) -> case unsafeFreezeSmallArray# ipv4 ipv3 of { (# ipv5, ipv6 #) -> (# ipv5, Collision dt ipv6 #) } }; 1# -> case unsafeFreezeSmallArray# ww1 w of { (# ipv3, ipv4 #) -> (# ipv3, Collision dt ipv4 #) } }; 0# -> (# w, Empty #); 1# -> case readSmallArray# ww1 0# w of { (# ipv3, ipv4 #) -> case ipv4 of { L dt3 dt4 -> (# ipv3, Leaf dt dt3 dt4 #) } } } }; } in $wstep1 dt1 ipv1 0# 0# n ipv }) of { (# ipv, ipv1 #) -> ipv1 } }; $wstep = \ @ s ww ww1 ww2 ww3 ww4 ww5 ww6 w -> case >=# ww3 ww6 of { __DEFAULT -> case and# ww5 ww2 of { __DEFAULT -> case indexSmallArray# ww ww3 of { (# ipv5 #) -> case go1 ipv5 of wild2 { __DEFAULT -> case writeSmallArray# ww1 ww4 wild2 w of s' { __DEFAULT -> $wstep ww ww1 ww2 (+# ww3 1#) (+# ww4 1#) (uncheckedShiftL# ww5 1#) ww6 s' }; Empty -> $wstep ww ww1 (and# ww2 (not# ww5)) (+# ww3 1#) ww4 (uncheckedShiftL# ww5 1#) ww6 w } }; 0## -> $wstep ww ww1 ww2 ww3 ww4 (uncheckedShiftL# ww5 1#) ww6 w }; 1# -> case ww4 of ds { __DEFAULT -> case cloneSmallMutableArray# ww1 0# ds w of { (# ipv5, ipv6 #) -> case unsafeFreezeSmallArray# ipv6 ipv5 of { (# ipv7, ipv8 #) -> case ds of { __DEFAULT -> (# ipv7, BitmapIndexed ww2 ipv8 #); 32# -> (# ipv7, Full ipv8 #) } } }; 0# -> (# w, Empty #); 1# -> case readSmallArray# ww1 0# w of ds1 { (# ipv5, ipv6 #) -> case ipv6 of { __DEFAULT -> case cloneSmallMutableArray# ww1 0# 1# ipv5 of { (# ipv7, ipv8 #) -> case unsafeFreezeSmallArray# ipv8 ipv7 of { (# ipv9, ipv10 #) -> (# ipv9, BitmapIndexed ww2 ipv10 #) } }; Leaf dt dt1 dt2 -> ds1; Collision dt dt1 -> ds1 } } } }; } in go1 eta -- RHS size: {terms: 339, types: 644, coercions: 0, joins: 0/6} mapMaybe = \ @ v1 @ v2 @ k f eta -> letrec { $wfilterA = \ ww ww1 -> case runRW# (\ s1 -> let { ipv = sizeofSmallArray# ww } in case newSmallArray# ipv undefinedElem s1 of { (# ipv1, ipv2 #) -> $wstep ww ipv2 ww1 0# 0# 1## ipv ipv1 }) of { (# ipv1, ipv2 #) -> ipv2 }; go1 = \ ds -> case ds of { Empty -> Empty; BitmapIndexed dt dt1 -> $wfilterA dt1 dt; Leaf dt dt1 dt2 -> case f dt2 of { Nothing -> Empty; Just v' -> case v' of v { __DEFAULT -> Leaf dt dt1 v } }; Full dt -> $wfilterA dt 4294967295##; Collision dt dt1 -> case runRW# (\ s1 -> let { n = sizeofSmallArray# dt1 } in case newSmallArray# n undefinedElem s1 of { (# ipv, ipv1 #) -> letrec { $wstep1 = \ @ s ww ww1 ww2 ww3 ww4 w -> case >=# ww2 ww4 of { __DEFAULT -> case indexSmallArray# ww ww2 of { (# ipv3 #) -> case ipv3 of { L ipv4 ipv5 -> case f ipv5 of { Nothing -> $wstep1 ww ww1 (+# ww2 1#) ww3 ww4 w; Just v' -> case writeSmallArray# ww1 ww3 (L ipv4 v') w of s' { __DEFAULT -> $wstep1 ww ww1 (+# ww2 1#) (+# ww3 1#) ww4 s' } } } }; 1# -> case ww3 of ds2 { __DEFAULT -> case ==# ww2 ds2 of { __DEFAULT -> case cloneSmallMutableArray# ww1 0# ds2 w of { (# ipv3, ipv4 #) -> case unsafeFreezeSmallArray# ipv4 ipv3 of { (# ipv5, ipv6 #) -> (# ipv5, Collision dt ipv6 #) } }; 1# -> case unsafeFreezeSmallArray# ww1 w of { (# ipv3, ipv4 #) -> (# ipv3, Collision dt ipv4 #) } }; 0# -> (# w, Empty #); 1# -> case readSmallArray# ww1 0# w of { (# ipv3, ipv4 #) -> case ipv4 of { L dt3 dt4 -> (# ipv3, Leaf dt dt3 dt4 #) } } } }; } in $wstep1 dt1 ipv1 0# 0# n ipv }) of { (# ipv, ipv1 #) -> ipv1 } }; $wstep = \ @ s ww ww1 ww2 ww3 ww4 ww5 ww6 w -> case >=# ww3 ww6 of { __DEFAULT -> case and# ww5 ww2 of { __DEFAULT -> case indexSmallArray# ww ww3 of { (# ipv5 #) -> case go1 ipv5 of wild2 { __DEFAULT -> case writeSmallArray# ww1 ww4 wild2 w of s' { __DEFAULT -> $wstep ww ww1 ww2 (+# ww3 1#) (+# ww4 1#) (uncheckedShiftL# ww5 1#) ww6 s' }; Empty -> $wstep ww ww1 (and# ww2 (not# ww5)) (+# ww3 1#) ww4 (uncheckedShiftL# ww5 1#) ww6 w } }; 0## -> $wstep ww ww1 ww2 ww3 ww4 (uncheckedShiftL# ww5 1#) ww6 w }; 1# -> case ww4 of ds { __DEFAULT -> case cloneSmallMutableArray# ww1 0# ds w of { (# ipv5, ipv6 #) -> case unsafeFreezeSmallArray# ipv6 ipv5 of { (# ipv7, ipv8 #) -> case ds of { __DEFAULT -> (# ipv7, BitmapIndexed ww2 ipv8 #); 32# -> (# ipv7, Full ipv8 #) } } }; 0# -> (# w, Empty #); 1# -> case readSmallArray# ww1 0# w of ds1 { (# ipv5, ipv6 #) -> case ipv6 of { __DEFAULT -> case cloneSmallMutableArray# ww1 0# 1# ipv5 of { (# ipv7, ipv8 #) -> case unsafeFreezeSmallArray# ipv8 ipv7 of { (# ipv9, ipv10 #) -> (# ipv9, BitmapIndexed ww2 ipv10 #) } }; Leaf dt dt1 dt2 -> ds1; Collision dt dt1 -> ds1 } } } }; } in go1 eta -- RHS size: {terms: 265, types: 697, coercions: 0, joins: 0/7} mapWithKey = \ @ k @ v1 @ v2 f eta -> letrec { $s$wgo = \ sc sc1 sc2 sc3 sc4 -> case >=# sc2 sc1 of { __DEFAULT -> case indexSmallArray# sc4 sc2 of { (# ipv #) -> case ipv of { L k1 v -> case f k1 v of v' { __DEFAULT -> case writeSmallArray# sc3 sc2 (L k1 v') sc of s' { __DEFAULT -> $s$wgo s' sc1 (+# sc2 1#) sc3 sc4 } } } }; 1# -> (# sc, MArray sc3 #) }; } in letrec { go = \ ds -> case ds of { Empty -> Empty; BitmapIndexed dt dt1 -> case runRW# (\ s1 -> let { ipv = sizeofSmallArray# dt1 } in case newSmallArray# ipv undefinedElem s1 of { (# ipv1, ipv2 #) -> case $s$wgo2 ipv1 ipv 0# ipv2 dt1 of { (# ipv3, ipv4 #) -> case ipv4 of { MArray ds3 -> case unsafeFreezeSmallArray# ds3 ipv3 of { (# ipv5, ipv6 #) -> (# ipv5, Array ipv6 #) } } } }) of { (# ipv1, ipv2 #) -> case ipv2 of { Array dt3 -> BitmapIndexed dt dt3 } }; Leaf dt dt1 dt2 -> case f dt1 dt2 of v { __DEFAULT -> Leaf dt dt1 v }; Full dt -> case runRW# (\ s1 -> let { ipv = sizeofSmallArray# dt } in case newSmallArray# ipv undefinedElem s1 of { (# ipv1, ipv2 #) -> case $s$wgo1 ipv1 ipv 0# ipv2 dt of { (# ipv3, ipv4 #) -> case ipv4 of { MArray ds3 -> case unsafeFreezeSmallArray# ds3 ipv3 of { (# ipv5, ipv6 #) -> (# ipv5, Array ipv6 #) } } } }) of { (# ipv1, ipv2 #) -> $WFull ipv2 }; Collision dt dt1 -> case runRW# (\ s1 -> let { ipv = sizeofSmallArray# dt1 } in case newSmallArray# ipv undefinedElem s1 of { (# ipv1, ipv2 #) -> case $s$wgo ipv1 ipv 0# ipv2 dt1 of { (# ipv3, ipv4 #) -> case ipv4 of { MArray ds3 -> case unsafeFreezeSmallArray# ds3 ipv3 of { (# ipv5, ipv6 #) -> (# ipv5, Array ipv6 #) } } } }) of { (# ipv1, ipv2 #) -> case ipv2 of { Array dt3 -> Collision dt dt3 } } }; $s$wgo1 = \ sc sc1 sc2 sc3 sc4 -> case >=# sc2 sc1 of { __DEFAULT -> case indexSmallArray# sc4 sc2 of { (# ipv #) -> case go ipv of vx { __DEFAULT -> case writeSmallArray# sc3 sc2 vx sc of s' { __DEFAULT -> $s$wgo1 s' sc1 (+# sc2 1#) sc3 sc4 } } }; 1# -> (# sc, MArray sc3 #) }; $s$wgo2 = \ sc sc1 sc2 sc3 sc4 -> case >=# sc2 sc1 of { __DEFAULT -> case indexSmallArray# sc4 sc2 of { (# ipv #) -> case go ipv of vx { __DEFAULT -> case writeSmallArray# sc3 sc2 vx sc of s' { __DEFAULT -> $s$wgo2 s' sc1 (+# sc2 1#) sc3 sc4 } } }; 1# -> (# sc, MArray sc3 #) }; } in go eta -- RHS size: {terms: 263, types: 696, coercions: 0, joins: 0/7} map = \ @ v1 @ v2 @ k f eta -> letrec { $s$wgo = \ sc sc1 sc2 sc3 sc4 -> case >=# sc2 sc1 of { __DEFAULT -> case indexSmallArray# sc4 sc2 of { (# ipv #) -> case ipv of { L k1 v -> case f v of v' { __DEFAULT -> case writeSmallArray# sc3 sc2 (L k1 v') sc of s' { __DEFAULT -> $s$wgo s' sc1 (+# sc2 1#) sc3 sc4 } } } }; 1# -> (# sc, MArray sc3 #) }; } in letrec { go = \ ds -> case ds of { Empty -> Empty; BitmapIndexed dt dt1 -> case runRW# (\ s1 -> let { ipv = sizeofSmallArray# dt1 } in case newSmallArray# ipv undefinedElem s1 of { (# ipv1, ipv2 #) -> case $s$wgo2 ipv1 ipv 0# ipv2 dt1 of { (# ipv3, ipv4 #) -> case ipv4 of { MArray ds3 -> case unsafeFreezeSmallArray# ds3 ipv3 of { (# ipv5, ipv6 #) -> (# ipv5, Array ipv6 #) } } } }) of { (# ipv1, ipv2 #) -> case ipv2 of { Array dt3 -> BitmapIndexed dt dt3 } }; Leaf dt dt1 dt2 -> case f dt2 of v { __DEFAULT -> Leaf dt dt1 v }; Full dt -> case runRW# (\ s1 -> let { ipv = sizeofSmallArray# dt } in case newSmallArray# ipv undefinedElem s1 of { (# ipv1, ipv2 #) -> case $s$wgo1 ipv1 ipv 0# ipv2 dt of { (# ipv3, ipv4 #) -> case ipv4 of { MArray ds3 -> case unsafeFreezeSmallArray# ds3 ipv3 of { (# ipv5, ipv6 #) -> (# ipv5, Array ipv6 #) } } } }) of { (# ipv1, ipv2 #) -> $WFull ipv2 }; Collision dt dt1 -> case runRW# (\ s1 -> let { ipv = sizeofSmallArray# dt1 } in case newSmallArray# ipv undefinedElem s1 of { (# ipv1, ipv2 #) -> case $s$wgo ipv1 ipv 0# ipv2 dt1 of { (# ipv3, ipv4 #) -> case ipv4 of { MArray ds3 -> case unsafeFreezeSmallArray# ds3 ipv3 of { (# ipv5, ipv6 #) -> (# ipv5, Array ipv6 #) } } } }) of { (# ipv1, ipv2 #) -> case ipv2 of { Array dt3 -> Collision dt dt3 } } }; $s$wgo1 = \ sc sc1 sc2 sc3 sc4 -> case >=# sc2 sc1 of { __DEFAULT -> case indexSmallArray# sc4 sc2 of { (# ipv #) -> case go ipv of vx { __DEFAULT -> case writeSmallArray# sc3 sc2 vx sc of s' { __DEFAULT -> $s$wgo1 s' sc1 (+# sc2 1#) sc3 sc4 } } }; 1# -> (# sc, MArray sc3 #) }; $s$wgo2 = \ sc sc1 sc2 sc3 sc4 -> case >=# sc2 sc1 of { __DEFAULT -> case indexSmallArray# sc4 sc2 of { (# ipv #) -> case go ipv of vx { __DEFAULT -> case writeSmallArray# sc3 sc2 vx sc of s' { __DEFAULT -> $s$wgo2 s' sc1 (+# sc2 1#) sc3 sc4 } } }; 1# -> (# sc, MArray sc3 #) }; } in go eta -- RHS size: {terms: 2, types: 0, coercions: 0, joins: 0/0} loc3 = I# 507# -- RHS size: {terms: 2, types: 0, coercions: 0, joins: 0/0} loc4 = I# 22# -- RHS size: {terms: 2, types: 0, coercions: 0, joins: 0/0} loc5 = I# 42# -- RHS size: {terms: 8, types: 0, coercions: 0, joins: 0/0} $dIP2 = SrcLoc lvl2 lvl3 lvl5 loc3 loc4 loc3 loc5 -- RHS size: {terms: 4, types: 0, coercions: 0, joins: 0/0} $dIP3 = PushCallStack lvl1 $dIP2 EmptyCallStack -- RHS size: {terms: 1, types: 0, coercions: 0, joins: 0/0} lvl22 = "Data/HashMap/Internal/Strict.hs:(439,5)-(503,20)|function go"# -- RHS size: {terms: 4, types: 8, coercions: 0, joins: 0/0} lvl23 = \ @ v @ k -> patError lvl22 -- RHS size: {terms: 1, types: 0, coercions: 0, joins: 0/0} lvl24 = "leafHashCode"# -- RHS size: {terms: 4, types: 2, coercions: 4, joins: 0/0} lvl25 = error ($dIP3 `cast` ) (unpackCString# lvl24) -- RHS size: {terms: 1,431, types: 2,351, coercions: 0, joins: 13/37} unionWithKey = \ @ k @ v _ $dHashable eta eta1 eta2 -> let { lvl26 = \ x x1 y -> eta x y x1 } in let { $dEq1 = $p1Hashable $dHashable } in letrec { $wgoDifferentHash = \ ww ww1 ww2 w w1 -> let { x = uncheckedShiftL# 1## (word2Int# (and# (uncheckedShiftRL# ww1 ww) 31##)) } in let { y = uncheckedShiftL# 1## (word2Int# (and# (uncheckedShiftRL# ww2 ww) 31##)) } in case eqWord# x y of { __DEFAULT -> case ltWord# x y of { __DEFAULT -> case runRW# (\ s1 -> case newSmallArray# 2# w1 s1 of { (# ipv, ipv1 #) -> case writeSmallArray# ipv1 1# w ipv of s' { __DEFAULT -> case unsafeFreezeSmallArray# ipv1 s' of { (# ipv2, ipv3 #) -> (# ipv2, Array ipv3 #) } } }) of { (# ipv, ipv1 #) -> case ipv1 of { Array dt1 -> BitmapIndexed (or# x y) dt1 } }; 1# -> case runRW# (\ s1 -> case newSmallArray# 2# w s1 of { (# ipv, ipv1 #) -> case writeSmallArray# ipv1 1# w1 ipv of s' { __DEFAULT -> case unsafeFreezeSmallArray# ipv1 s' of { (# ipv2, ipv3 #) -> (# ipv2, Array ipv3 #) } } }) of { (# ipv, ipv1 #) -> case ipv1 of { Array dt1 -> BitmapIndexed (or# x y) dt1 } } }; 1# -> case $wgo (+# ww 5#) w w1 of vx { __DEFAULT -> case runRW# (\ s1 -> case newSmallArray# 1# vx s1 of { (# ipv, ipv1 #) -> case unsafeFreezeSmallArray# ipv1 ipv of { (# ipv2, ipv3 #) -> (# ipv2, Array ipv3 #) } }) of { (# ipv, ipv1 #) -> case ipv1 of { Array dt1 -> BitmapIndexed x dt1 } } } }; $wgo = \ ww w w1 -> case w1 of wild { __DEFAULT -> join { fail _ = case wild of wild1 { __DEFAULT -> case w of wild2 { __DEFAULT -> case wild1 of { __DEFAULT -> lvl23; Full dt -> join { $j x# = let { i# = word2Int# (and# (uncheckedShiftRL# x# ww) 31##) } in case indexSmallArray# dt i# of { (# ipv #) -> case $wgo (+# ww 5#) wild2 ipv of vx { __DEFAULT -> case runRW# (\ s1 -> case thawSmallArray# dt 0# 32# s1 of { (# ipv1, ipv2 #) -> case writeSmallArray# ipv2 i# vx ipv1 of s' { __DEFAULT -> case unsafeFreezeSmallArray# ipv2 s' of { (# ipv4, ipv5 #) -> (# ipv4, Array ipv5 #) } } }) of { (# ipv1, ipv2 #) -> $WFull ipv2 } } } } in case wild2 of { __DEFAULT -> case lvl25 of wild5 { }; Leaf dt1 dt2 dt3 -> jump $j dt1; Collision dt1 dt2 -> jump $j dt1 } }; Full dt -> join { $j x# = let { i# = word2Int# (and# (uncheckedShiftRL# x# ww) 31##) } in case indexSmallArray# dt i# of { (# ipv #) -> case $wgo (+# ww 5#) ipv wild1 of vx { __DEFAULT -> case runRW# (\ s1 -> case thawSmallArray# dt 0# 32# s1 of { (# ipv1, ipv2 #) -> case writeSmallArray# ipv2 i# vx ipv1 of s' { __DEFAULT -> case unsafeFreezeSmallArray# ipv2 s' of { (# ipv4, ipv5 #) -> (# ipv4, Array ipv5 #) } } }) of { (# ipv1, ipv2 #) -> $WFull ipv2 } } } } in case wild1 of { Leaf dt1 dt2 dt3 -> jump $j dt1; Full ipv -> case lvl25 of wild4 { }; Collision dt1 dt2 -> jump $j dt1 } }; BitmapIndexed dt dt1 -> join { $j y# = case and# dt y# of { __DEFAULT -> let { i# = word2Int# (popCnt# (and# dt (minusWord# y# 1##))) } in case indexSmallArray# dt1 i# of { (# ipv #) -> case $wgo (+# ww 5#) w ipv of vx { __DEFAULT -> case runRW# (\ s1 -> case thawSmallArray# dt1 0# (sizeofSmallArray# dt1) s1 of { (# ipv1, ipv2 #) -> case writeSmallArray# ipv2 i# vx ipv1 of s' { __DEFAULT -> case unsafeFreezeSmallArray# ipv2 s' of { (# ipv3, ipv4 #) -> (# ipv3, Array ipv4 #) } } }) of { (# ipv1, ipv2 #) -> case ipv2 of { Array dt3 -> BitmapIndexed dt dt3 } } } }; 0## -> case w of vx { __DEFAULT -> case runRW# (\ s1 -> let { ipv = sizeofSmallArray# dt1 } in case newSmallArray# (+# ipv 1#) undefinedElem s1 of { (# ipv1, ipv2 #) -> let { n# = word2Int# (popCnt# (and# dt (minusWord# y# 1##))) } in case copySmallArray# dt1 0# ipv2 0# n# ipv1 of s2 { __DEFAULT -> case writeSmallArray# ipv2 n# vx s2 of s' { __DEFAULT -> case copySmallArray# dt1 n# ipv2 (+# n# 1#) (-# ipv n#) s' of s4 { __DEFAULT -> case unsafeFreezeSmallArray# ipv2 s4 of { (# ipv3, ipv4 #) -> (# ipv3, Array ipv4 #) } } } } }) of { (# ipv1, ipv2 #) -> case ipv2 of { Array ww2 -> case or# dt y# of wild3 { __DEFAULT -> BitmapIndexed wild3 ww2; 4294967295## -> Full ww2 } } } } } } in case w of { __DEFAULT -> case lvl25 of wild3 { }; Leaf dt2 dt3 dt4 -> jump $j (uncheckedShiftL# 1## (word2Int# (and# (uncheckedShiftRL# dt2 ww) 31##))); Collision dt2 dt3 -> jump $j (uncheckedShiftL# 1## (word2Int# (and# (uncheckedShiftRL# dt2 ww) 31##))) } } } in case w of wild1 { Empty -> wild; BitmapIndexed dt dt1 -> case wild of wild2 { __DEFAULT -> join { $j y# = case and# dt y# of { __DEFAULT -> let { i# = word2Int# (popCnt# (and# dt (minusWord# y# 1##))) } in case indexSmallArray# dt1 i# of { (# ipv #) -> case $wgo (+# ww 5#) ipv wild2 of vx { __DEFAULT -> case runRW# (\ s1 -> case thawSmallArray# dt1 0# (sizeofSmallArray# dt1) s1 of { (# ipv1, ipv2 #) -> case writeSmallArray# ipv2 i# vx ipv1 of s' { __DEFAULT -> case unsafeFreezeSmallArray# ipv2 s' of { (# ipv3, ipv4 #) -> (# ipv3, Array ipv4 #) } } }) of { (# ipv1, ipv2 #) -> case ipv2 of { Array dt3 -> BitmapIndexed dt dt3 } } } }; 0## -> case runRW# (\ s1 -> let { ipv = sizeofSmallArray# dt1 } in case newSmallArray# (+# ipv 1#) undefinedElem s1 of { (# ipv1, ipv2 #) -> let { n# = word2Int# (popCnt# (and# dt (minusWord# y# 1##))) } in case copySmallArray# dt1 0# ipv2 0# n# ipv1 of s2 { __DEFAULT -> case writeSmallArray# ipv2 n# wild2 s2 of s' { __DEFAULT -> case copySmallArray# dt1 n# ipv2 (+# n# 1#) (-# ipv n#) s' of s4 { __DEFAULT -> case unsafeFreezeSmallArray# ipv2 s4 of { (# ipv3, ipv4 #) -> (# ipv3, Array ipv4 #) } } } } }) of { (# ipv1, ipv2 #) -> case ipv2 of { Array ww2 -> case or# dt y# of wild4 { __DEFAULT -> BitmapIndexed wild4 ww2; 4294967295## -> Full ww2 } } } } } in case wild2 of { Leaf dt2 dt3 dt4 -> jump $j (uncheckedShiftL# 1## (word2Int# (and# (uncheckedShiftRL# dt2 ww) 31##))); Collision dt2 dt3 -> jump $j (uncheckedShiftL# 1## (word2Int# (and# (uncheckedShiftRL# dt2 ww) 31##))) }; BitmapIndexed dt2 dt3 -> case runRW# (\ s1 -> let { b' = or# dt dt2 } in case newSmallArray# (word2Int# (popCnt# b')) undefinedElem s1 of { (# ipv, ipv1 #) -> let { f = +# ww 5# } in let { ba = and# dt dt2 } in join { exit w2 = case unsafeFreezeSmallArray# ipv1 w2 of { (# ipv4, ipv5 #) -> (# ipv4, Array ipv5 #) } } in joinrec { $wgo1 ww1 ww2 ww3 ww4 w2 = case gtWord# ww4 b' of { __DEFAULT -> case and# b' ww4 of { __DEFAULT -> case and# ba ww4 of { __DEFAULT -> case indexSmallArray# dt1 ww2 of { (# ipv6 #) -> case indexSmallArray# dt3 ww3 of { (# ipv7 #) -> case $wgo f ipv6 ipv7 of vx { __DEFAULT -> case writeSmallArray# ipv1 ww1 vx w2 of s' { __DEFAULT -> jump $wgo1 (+# ww1 1#) (+# ww2 1#) (+# ww3 1#) (uncheckedShiftL# ww4 1#) s' } } } }; 0## -> case and# dt ww4 of { __DEFAULT -> case indexSmallArray# dt1 ww2 of { (# ipv6 #) -> case writeSmallArray# ipv1 ww1 ipv6 w2 of s' { __DEFAULT -> jump $wgo1 (+# ww1 1#) (+# ww2 1#) ww3 (uncheckedShiftL# ww4 1#) s' } }; 0## -> case indexSmallArray# dt3 ww3 of { (# ipv6 #) -> case writeSmallArray# ipv1 ww1 ipv6 w2 of s' { __DEFAULT -> jump $wgo1 (+# ww1 1#) ww2 (+# ww3 1#) (uncheckedShiftL# ww4 1#) s' } } } }; 0## -> jump $wgo1 ww1 ww2 ww3 (uncheckedShiftL# ww4 1#) w2 }; 1# -> jump exit w2 }; } in jump $wgo1 0# 0# 0# (and# b' (int2Word# (negateInt# (word2Int# b')))) ipv }) of { (# ipv, ipv1 #) -> case ipv1 of { Array ww2 -> case or# dt dt2 of wild3 { __DEFAULT -> BitmapIndexed wild3 ww2; 4294967295## -> Full ww2 } } }; Full dt2 -> case runRW# (\ s1 -> let { b' = or# dt 4294967295## } in case newSmallArray# (word2Int# (popCnt# b')) undefinedElem s1 of { (# ipv, ipv1 #) -> let { f = +# ww 5# } in let { ba = and# dt 4294967295## } in join { exit w2 = case unsafeFreezeSmallArray# ipv1 w2 of { (# ipv4, ipv5 #) -> (# ipv4, Array ipv5 #) } } in joinrec { $wgo1 ww1 ww2 ww3 ww4 w2 = case gtWord# ww4 b' of { __DEFAULT -> case and# b' ww4 of { __DEFAULT -> case and# ba ww4 of { __DEFAULT -> case indexSmallArray# dt1 ww2 of { (# ipv6 #) -> case indexSmallArray# dt2 ww3 of { (# ipv7 #) -> case $wgo f ipv6 ipv7 of vx { __DEFAULT -> case writeSmallArray# ipv1 ww1 vx w2 of s' { __DEFAULT -> jump $wgo1 (+# ww1 1#) (+# ww2 1#) (+# ww3 1#) (uncheckedShiftL# ww4 1#) s' } } } }; 0## -> case and# dt ww4 of { __DEFAULT -> case indexSmallArray# dt1 ww2 of { (# ipv6 #) -> case writeSmallArray# ipv1 ww1 ipv6 w2 of s' { __DEFAULT -> jump $wgo1 (+# ww1 1#) (+# ww2 1#) ww3 (uncheckedShiftL# ww4 1#) s' } }; 0## -> case indexSmallArray# dt2 ww3 of { (# ipv6 #) -> case writeSmallArray# ipv1 ww1 ipv6 w2 of s' { __DEFAULT -> jump $wgo1 (+# ww1 1#) ww2 (+# ww3 1#) (uncheckedShiftL# ww4 1#) s' } } } }; 0## -> jump $wgo1 ww1 ww2 ww3 (uncheckedShiftL# ww4 1#) w2 }; 1# -> jump exit w2 }; } in jump $wgo1 0# 0# 0# (and# b' (int2Word# (negateInt# (word2Int# b')))) ipv }) of { (# ipv, ipv1 #) -> $WFull ipv1 } }; Leaf dt dt1 dt2 -> case wild of wild2 { __DEFAULT -> jump fail void#; Leaf dt3 dt4 dt5 -> case eqWord# dt dt3 of { __DEFAULT -> $wgoDifferentHash ww dt dt3 wild1 wild2; 1# -> case == $dEq1 dt1 dt4 of { False -> case runRW# (\ s1 -> case newSmallArray# 2# (L dt1 dt2) s1 of { (# ipv4, ipv5 #) -> case writeSmallArray# ipv5 1# (L dt4 dt5) ipv4 of s' { __DEFAULT -> case unsafeFreezeSmallArray# ipv5 s' of { (# ipv6, ipv7 #) -> (# ipv6, Array ipv7 #) } } }) of { (# ipv4, ipv5 #) -> case ipv5 of { Array dt7 -> Collision dt dt7 } }; True -> case eta dt1 dt2 dt5 of v1 { __DEFAULT -> Leaf dt dt1 v1 } } }; Collision dt3 dt4 -> case eqWord# dt dt3 of { __DEFAULT -> $wgoDifferentHash ww dt dt3 wild1 wild2; 1# -> case $wupdateOrSnocWithKey $dEq1 eta dt1 dt2 dt4 of { Array dt6 -> Collision dt dt6 } } }; Full dt -> case wild of { __DEFAULT -> jump fail void#; BitmapIndexed dt1 dt2 -> case runRW# (\ s1 -> let { b' = or# 4294967295## dt1 } in case newSmallArray# (word2Int# (popCnt# b')) undefinedElem s1 of { (# ipv, ipv1 #) -> let { f = +# ww 5# } in let { ba = and# 4294967295## dt1 } in join { exit w2 = case unsafeFreezeSmallArray# ipv1 w2 of { (# ipv4, ipv5 #) -> (# ipv4, Array ipv5 #) } } in joinrec { $wgo1 ww1 ww2 ww3 ww4 w2 = case gtWord# ww4 b' of { __DEFAULT -> case and# b' ww4 of { __DEFAULT -> case and# ba ww4 of { __DEFAULT -> case indexSmallArray# dt ww2 of { (# ipv6 #) -> case indexSmallArray# dt2 ww3 of { (# ipv7 #) -> case $wgo f ipv6 ipv7 of vx { __DEFAULT -> case writeSmallArray# ipv1 ww1 vx w2 of s' { __DEFAULT -> jump $wgo1 (+# ww1 1#) (+# ww2 1#) (+# ww3 1#) (uncheckedShiftL# ww4 1#) s' } } } }; 0## -> case and# 4294967295## ww4 of { __DEFAULT -> case indexSmallArray# dt ww2 of { (# ipv6 #) -> case writeSmallArray# ipv1 ww1 ipv6 w2 of s' { __DEFAULT -> jump $wgo1 (+# ww1 1#) (+# ww2 1#) ww3 (uncheckedShiftL# ww4 1#) s' } }; 0## -> case indexSmallArray# dt2 ww3 of { (# ipv6 #) -> case writeSmallArray# ipv1 ww1 ipv6 w2 of s' { __DEFAULT -> jump $wgo1 (+# ww1 1#) ww2 (+# ww3 1#) (uncheckedShiftL# ww4 1#) s' } } } }; 0## -> jump $wgo1 ww1 ww2 ww3 (uncheckedShiftL# ww4 1#) w2 }; 1# -> jump exit w2 }; } in jump $wgo1 0# 0# 0# (and# b' (int2Word# (negateInt# (word2Int# b')))) ipv }) of { (# ipv, ipv1 #) -> $WFull ipv1 }; Full dt1 -> case runRW# (\ s1 -> case newSmallArray# (word2Int# (popCnt# 4294967295##)) undefinedElem s1 of { (# ipv, ipv1 #) -> let { f = +# ww 5# } in join { exit w2 = case unsafeFreezeSmallArray# ipv1 w2 of { (# ipv4, ipv5 #) -> (# ipv4, Array ipv5 #) } } in joinrec { $wgo1 ww1 ww2 ww3 ww4 w2 = case gtWord# ww4 4294967295## of { __DEFAULT -> case and# 4294967295## ww4 of { __DEFAULT -> case indexSmallArray# dt ww2 of { (# ipv6 #) -> case indexSmallArray# dt1 ww3 of { (# ipv7 #) -> case $wgo f ipv6 ipv7 of vx { __DEFAULT -> case writeSmallArray# ipv1 ww1 vx w2 of s' { __DEFAULT -> jump $wgo1 (+# ww1 1#) (+# ww2 1#) (+# ww3 1#) (uncheckedShiftL# ww4 1#) s' } } } }; 0## -> jump $wgo1 ww1 ww2 ww3 (uncheckedShiftL# ww4 1#) w2 }; 1# -> jump exit w2 }; } in jump $wgo1 0# 0# 0# 1## ipv }) of { (# ipv, ipv1 #) -> $WFull ipv1 } }; Collision dt dt1 -> case wild of wild2 { __DEFAULT -> jump fail void#; Leaf dt2 dt3 dt4 -> case eqWord# dt dt2 of { __DEFAULT -> $wgoDifferentHash ww dt dt2 wild1 wild2; 1# -> case $wupdateOrSnocWithKey $dEq1 lvl26 dt3 dt4 dt1 of { Array dt6 -> Collision dt dt6 } }; Collision dt2 dt3 -> case eqWord# dt dt2 of { __DEFAULT -> $wgoDifferentHash ww dt dt2 wild1 wild2; 1# -> case $wupdateOrConcatWithKey $dEq1 eta dt1 dt3 of { Array dt5 -> Collision dt dt5 } } } }; Empty -> w }; } in $wgo 0# eta1 eta2 -- RHS size: {terms: 1,432, types: 2,355, coercions: 0, joins: 13/38} unionWith = \ @ k @ v _ $dHashable eta eta1 eta2 -> let { lvl26 = \ _ x1 y -> eta y x1 } in let { $dEq1 = $p1Hashable $dHashable } in let { f = \ _ -> eta } in letrec { $wgoDifferentHash = \ ww ww1 ww2 w w1 -> let { x = uncheckedShiftL# 1## (word2Int# (and# (uncheckedShiftRL# ww1 ww) 31##)) } in let { y = uncheckedShiftL# 1## (word2Int# (and# (uncheckedShiftRL# ww2 ww) 31##)) } in case eqWord# x y of { __DEFAULT -> case ltWord# x y of { __DEFAULT -> case runRW# (\ s1 -> case newSmallArray# 2# w1 s1 of { (# ipv, ipv1 #) -> case writeSmallArray# ipv1 1# w ipv of s' { __DEFAULT -> case unsafeFreezeSmallArray# ipv1 s' of { (# ipv2, ipv3 #) -> (# ipv2, Array ipv3 #) } } }) of { (# ipv, ipv1 #) -> case ipv1 of { Array dt1 -> BitmapIndexed (or# x y) dt1 } }; 1# -> case runRW# (\ s1 -> case newSmallArray# 2# w s1 of { (# ipv, ipv1 #) -> case writeSmallArray# ipv1 1# w1 ipv of s' { __DEFAULT -> case unsafeFreezeSmallArray# ipv1 s' of { (# ipv2, ipv3 #) -> (# ipv2, Array ipv3 #) } } }) of { (# ipv, ipv1 #) -> case ipv1 of { Array dt1 -> BitmapIndexed (or# x y) dt1 } } }; 1# -> case $wgo (+# ww 5#) w w1 of vx { __DEFAULT -> case runRW# (\ s1 -> case newSmallArray# 1# vx s1 of { (# ipv, ipv1 #) -> case unsafeFreezeSmallArray# ipv1 ipv of { (# ipv2, ipv3 #) -> (# ipv2, Array ipv3 #) } }) of { (# ipv, ipv1 #) -> case ipv1 of { Array dt1 -> BitmapIndexed x dt1 } } } }; $wgo = \ ww w w1 -> case w1 of wild { __DEFAULT -> join { fail _ = case wild of wild1 { __DEFAULT -> case w of wild2 { __DEFAULT -> case wild1 of { __DEFAULT -> lvl23; Full dt -> join { $j x# = let { i# = word2Int# (and# (uncheckedShiftRL# x# ww) 31##) } in case indexSmallArray# dt i# of { (# ipv #) -> case $wgo (+# ww 5#) wild2 ipv of vx { __DEFAULT -> case runRW# (\ s1 -> case thawSmallArray# dt 0# 32# s1 of { (# ipv1, ipv2 #) -> case writeSmallArray# ipv2 i# vx ipv1 of s' { __DEFAULT -> case unsafeFreezeSmallArray# ipv2 s' of { (# ipv4, ipv5 #) -> (# ipv4, Array ipv5 #) } } }) of { (# ipv1, ipv2 #) -> $WFull ipv2 } } } } in case wild2 of { __DEFAULT -> case lvl25 of wild5 { }; Leaf dt1 dt2 dt3 -> jump $j dt1; Collision dt1 dt2 -> jump $j dt1 } }; Full dt -> join { $j x# = let { i# = word2Int# (and# (uncheckedShiftRL# x# ww) 31##) } in case indexSmallArray# dt i# of { (# ipv #) -> case $wgo (+# ww 5#) ipv wild1 of vx { __DEFAULT -> case runRW# (\ s1 -> case thawSmallArray# dt 0# 32# s1 of { (# ipv1, ipv2 #) -> case writeSmallArray# ipv2 i# vx ipv1 of s' { __DEFAULT -> case unsafeFreezeSmallArray# ipv2 s' of { (# ipv4, ipv5 #) -> (# ipv4, Array ipv5 #) } } }) of { (# ipv1, ipv2 #) -> $WFull ipv2 } } } } in case wild1 of { Leaf dt1 dt2 dt3 -> jump $j dt1; Full ipv -> case lvl25 of wild4 { }; Collision dt1 dt2 -> jump $j dt1 } }; BitmapIndexed dt dt1 -> join { $j y# = case and# dt y# of { __DEFAULT -> let { i# = word2Int# (popCnt# (and# dt (minusWord# y# 1##))) } in case indexSmallArray# dt1 i# of { (# ipv #) -> case $wgo (+# ww 5#) w ipv of vx { __DEFAULT -> case runRW# (\ s1 -> case thawSmallArray# dt1 0# (sizeofSmallArray# dt1) s1 of { (# ipv1, ipv2 #) -> case writeSmallArray# ipv2 i# vx ipv1 of s' { __DEFAULT -> case unsafeFreezeSmallArray# ipv2 s' of { (# ipv3, ipv4 #) -> (# ipv3, Array ipv4 #) } } }) of { (# ipv1, ipv2 #) -> case ipv2 of { Array dt3 -> BitmapIndexed dt dt3 } } } }; 0## -> case w of vx { __DEFAULT -> case runRW# (\ s1 -> let { ipv = sizeofSmallArray# dt1 } in case newSmallArray# (+# ipv 1#) undefinedElem s1 of { (# ipv1, ipv2 #) -> let { n# = word2Int# (popCnt# (and# dt (minusWord# y# 1##))) } in case copySmallArray# dt1 0# ipv2 0# n# ipv1 of s2 { __DEFAULT -> case writeSmallArray# ipv2 n# vx s2 of s' { __DEFAULT -> case copySmallArray# dt1 n# ipv2 (+# n# 1#) (-# ipv n#) s' of s4 { __DEFAULT -> case unsafeFreezeSmallArray# ipv2 s4 of { (# ipv3, ipv4 #) -> (# ipv3, Array ipv4 #) } } } } }) of { (# ipv1, ipv2 #) -> case ipv2 of { Array ww2 -> case or# dt y# of wild3 { __DEFAULT -> BitmapIndexed wild3 ww2; 4294967295## -> Full ww2 } } } } } } in case w of { __DEFAULT -> case lvl25 of wild3 { }; Leaf dt2 dt3 dt4 -> jump $j (uncheckedShiftL# 1## (word2Int# (and# (uncheckedShiftRL# dt2 ww) 31##))); Collision dt2 dt3 -> jump $j (uncheckedShiftL# 1## (word2Int# (and# (uncheckedShiftRL# dt2 ww) 31##))) } } } in case w of wild1 { Empty -> wild; BitmapIndexed dt dt1 -> case wild of wild2 { __DEFAULT -> join { $j y# = case and# dt y# of { __DEFAULT -> let { i# = word2Int# (popCnt# (and# dt (minusWord# y# 1##))) } in case indexSmallArray# dt1 i# of { (# ipv #) -> case $wgo (+# ww 5#) ipv wild2 of vx { __DEFAULT -> case runRW# (\ s1 -> case thawSmallArray# dt1 0# (sizeofSmallArray# dt1) s1 of { (# ipv1, ipv2 #) -> case writeSmallArray# ipv2 i# vx ipv1 of s' { __DEFAULT -> case unsafeFreezeSmallArray# ipv2 s' of { (# ipv3, ipv4 #) -> (# ipv3, Array ipv4 #) } } }) of { (# ipv1, ipv2 #) -> case ipv2 of { Array dt3 -> BitmapIndexed dt dt3 } } } }; 0## -> case runRW# (\ s1 -> let { ipv = sizeofSmallArray# dt1 } in case newSmallArray# (+# ipv 1#) undefinedElem s1 of { (# ipv1, ipv2 #) -> let { n# = word2Int# (popCnt# (and# dt (minusWord# y# 1##))) } in case copySmallArray# dt1 0# ipv2 0# n# ipv1 of s2 { __DEFAULT -> case writeSmallArray# ipv2 n# wild2 s2 of s' { __DEFAULT -> case copySmallArray# dt1 n# ipv2 (+# n# 1#) (-# ipv n#) s' of s4 { __DEFAULT -> case unsafeFreezeSmallArray# ipv2 s4 of { (# ipv3, ipv4 #) -> (# ipv3, Array ipv4 #) } } } } }) of { (# ipv1, ipv2 #) -> case ipv2 of { Array ww2 -> case or# dt y# of wild4 { __DEFAULT -> BitmapIndexed wild4 ww2; 4294967295## -> Full ww2 } } } } } in case wild2 of { Leaf dt2 dt3 dt4 -> jump $j (uncheckedShiftL# 1## (word2Int# (and# (uncheckedShiftRL# dt2 ww) 31##))); Collision dt2 dt3 -> jump $j (uncheckedShiftL# 1## (word2Int# (and# (uncheckedShiftRL# dt2 ww) 31##))) }; BitmapIndexed dt2 dt3 -> case runRW# (\ s1 -> let { b' = or# dt dt2 } in case newSmallArray# (word2Int# (popCnt# b')) undefinedElem s1 of { (# ipv, ipv1 #) -> let { f1 = +# ww 5# } in let { ba = and# dt dt2 } in join { exit w2 = case unsafeFreezeSmallArray# ipv1 w2 of { (# ipv4, ipv5 #) -> (# ipv4, Array ipv5 #) } } in joinrec { $wgo1 ww1 ww2 ww3 ww4 w2 = case gtWord# ww4 b' of { __DEFAULT -> case and# b' ww4 of { __DEFAULT -> case and# ba ww4 of { __DEFAULT -> case indexSmallArray# dt1 ww2 of { (# ipv6 #) -> case indexSmallArray# dt3 ww3 of { (# ipv7 #) -> case $wgo f1 ipv6 ipv7 of vx { __DEFAULT -> case writeSmallArray# ipv1 ww1 vx w2 of s' { __DEFAULT -> jump $wgo1 (+# ww1 1#) (+# ww2 1#) (+# ww3 1#) (uncheckedShiftL# ww4 1#) s' } } } }; 0## -> case and# dt ww4 of { __DEFAULT -> case indexSmallArray# dt1 ww2 of { (# ipv6 #) -> case writeSmallArray# ipv1 ww1 ipv6 w2 of s' { __DEFAULT -> jump $wgo1 (+# ww1 1#) (+# ww2 1#) ww3 (uncheckedShiftL# ww4 1#) s' } }; 0## -> case indexSmallArray# dt3 ww3 of { (# ipv6 #) -> case writeSmallArray# ipv1 ww1 ipv6 w2 of s' { __DEFAULT -> jump $wgo1 (+# ww1 1#) ww2 (+# ww3 1#) (uncheckedShiftL# ww4 1#) s' } } } }; 0## -> jump $wgo1 ww1 ww2 ww3 (uncheckedShiftL# ww4 1#) w2 }; 1# -> jump exit w2 }; } in jump $wgo1 0# 0# 0# (and# b' (int2Word# (negateInt# (word2Int# b')))) ipv }) of { (# ipv, ipv1 #) -> case ipv1 of { Array ww2 -> case or# dt dt2 of wild3 { __DEFAULT -> BitmapIndexed wild3 ww2; 4294967295## -> Full ww2 } } }; Full dt2 -> case runRW# (\ s1 -> let { b' = or# dt 4294967295## } in case newSmallArray# (word2Int# (popCnt# b')) undefinedElem s1 of { (# ipv, ipv1 #) -> let { f1 = +# ww 5# } in let { ba = and# dt 4294967295## } in join { exit w2 = case unsafeFreezeSmallArray# ipv1 w2 of { (# ipv4, ipv5 #) -> (# ipv4, Array ipv5 #) } } in joinrec { $wgo1 ww1 ww2 ww3 ww4 w2 = case gtWord# ww4 b' of { __DEFAULT -> case and# b' ww4 of { __DEFAULT -> case and# ba ww4 of { __DEFAULT -> case indexSmallArray# dt1 ww2 of { (# ipv6 #) -> case indexSmallArray# dt2 ww3 of { (# ipv7 #) -> case $wgo f1 ipv6 ipv7 of vx { __DEFAULT -> case writeSmallArray# ipv1 ww1 vx w2 of s' { __DEFAULT -> jump $wgo1 (+# ww1 1#) (+# ww2 1#) (+# ww3 1#) (uncheckedShiftL# ww4 1#) s' } } } }; 0## -> case and# dt ww4 of { __DEFAULT -> case indexSmallArray# dt1 ww2 of { (# ipv6 #) -> case writeSmallArray# ipv1 ww1 ipv6 w2 of s' { __DEFAULT -> jump $wgo1 (+# ww1 1#) (+# ww2 1#) ww3 (uncheckedShiftL# ww4 1#) s' } }; 0## -> case indexSmallArray# dt2 ww3 of { (# ipv6 #) -> case writeSmallArray# ipv1 ww1 ipv6 w2 of s' { __DEFAULT -> jump $wgo1 (+# ww1 1#) ww2 (+# ww3 1#) (uncheckedShiftL# ww4 1#) s' } } } }; 0## -> jump $wgo1 ww1 ww2 ww3 (uncheckedShiftL# ww4 1#) w2 }; 1# -> jump exit w2 }; } in jump $wgo1 0# 0# 0# (and# b' (int2Word# (negateInt# (word2Int# b')))) ipv }) of { (# ipv, ipv1 #) -> $WFull ipv1 } }; Leaf dt dt1 dt2 -> case wild of wild2 { __DEFAULT -> jump fail void#; Leaf dt3 dt4 dt5 -> case eqWord# dt dt3 of { __DEFAULT -> $wgoDifferentHash ww dt dt3 wild1 wild2; 1# -> case == $dEq1 dt1 dt4 of { False -> case runRW# (\ s1 -> case newSmallArray# 2# (L dt1 dt2) s1 of { (# ipv4, ipv5 #) -> case writeSmallArray# ipv5 1# (L dt4 dt5) ipv4 of s' { __DEFAULT -> case unsafeFreezeSmallArray# ipv5 s' of { (# ipv6, ipv7 #) -> (# ipv6, Array ipv7 #) } } }) of { (# ipv4, ipv5 #) -> case ipv5 of { Array dt7 -> Collision dt dt7 } }; True -> case eta dt2 dt5 of v1 { __DEFAULT -> Leaf dt dt1 v1 } } }; Collision dt3 dt4 -> case eqWord# dt dt3 of { __DEFAULT -> $wgoDifferentHash ww dt dt3 wild1 wild2; 1# -> case $wupdateOrSnocWithKey $dEq1 f dt1 dt2 dt4 of { Array dt6 -> Collision dt dt6 } } }; Full dt -> case wild of { __DEFAULT -> jump fail void#; BitmapIndexed dt1 dt2 -> case runRW# (\ s1 -> let { b' = or# 4294967295## dt1 } in case newSmallArray# (word2Int# (popCnt# b')) undefinedElem s1 of { (# ipv, ipv1 #) -> let { f1 = +# ww 5# } in let { ba = and# 4294967295## dt1 } in join { exit w2 = case unsafeFreezeSmallArray# ipv1 w2 of { (# ipv4, ipv5 #) -> (# ipv4, Array ipv5 #) } } in joinrec { $wgo1 ww1 ww2 ww3 ww4 w2 = case gtWord# ww4 b' of { __DEFAULT -> case and# b' ww4 of { __DEFAULT -> case and# ba ww4 of { __DEFAULT -> case indexSmallArray# dt ww2 of { (# ipv6 #) -> case indexSmallArray# dt2 ww3 of { (# ipv7 #) -> case $wgo f1 ipv6 ipv7 of vx { __DEFAULT -> case writeSmallArray# ipv1 ww1 vx w2 of s' { __DEFAULT -> jump $wgo1 (+# ww1 1#) (+# ww2 1#) (+# ww3 1#) (uncheckedShiftL# ww4 1#) s' } } } }; 0## -> case and# 4294967295## ww4 of { __DEFAULT -> case indexSmallArray# dt ww2 of { (# ipv6 #) -> case writeSmallArray# ipv1 ww1 ipv6 w2 of s' { __DEFAULT -> jump $wgo1 (+# ww1 1#) (+# ww2 1#) ww3 (uncheckedShiftL# ww4 1#) s' } }; 0## -> case indexSmallArray# dt2 ww3 of { (# ipv6 #) -> case writeSmallArray# ipv1 ww1 ipv6 w2 of s' { __DEFAULT -> jump $wgo1 (+# ww1 1#) ww2 (+# ww3 1#) (uncheckedShiftL# ww4 1#) s' } } } }; 0## -> jump $wgo1 ww1 ww2 ww3 (uncheckedShiftL# ww4 1#) w2 }; 1# -> jump exit w2 }; } in jump $wgo1 0# 0# 0# (and# b' (int2Word# (negateInt# (word2Int# b')))) ipv }) of { (# ipv, ipv1 #) -> $WFull ipv1 }; Full dt1 -> case runRW# (\ s1 -> case newSmallArray# (word2Int# (popCnt# 4294967295##)) undefinedElem s1 of { (# ipv, ipv1 #) -> let { f1 = +# ww 5# } in join { exit w2 = case unsafeFreezeSmallArray# ipv1 w2 of { (# ipv4, ipv5 #) -> (# ipv4, Array ipv5 #) } } in joinrec { $wgo1 ww1 ww2 ww3 ww4 w2 = case gtWord# ww4 4294967295## of { __DEFAULT -> case and# 4294967295## ww4 of { __DEFAULT -> case indexSmallArray# dt ww2 of { (# ipv6 #) -> case indexSmallArray# dt1 ww3 of { (# ipv7 #) -> case $wgo f1 ipv6 ipv7 of vx { __DEFAULT -> case writeSmallArray# ipv1 ww1 vx w2 of s' { __DEFAULT -> jump $wgo1 (+# ww1 1#) (+# ww2 1#) (+# ww3 1#) (uncheckedShiftL# ww4 1#) s' } } } }; 0## -> jump $wgo1 ww1 ww2 ww3 (uncheckedShiftL# ww4 1#) w2 }; 1# -> jump exit w2 }; } in jump $wgo1 0# 0# 0# 1## ipv }) of { (# ipv, ipv1 #) -> $WFull ipv1 } }; Collision dt dt1 -> case wild of wild2 { __DEFAULT -> jump fail void#; Leaf dt2 dt3 dt4 -> case eqWord# dt dt2 of { __DEFAULT -> $wgoDifferentHash ww dt dt2 wild1 wild2; 1# -> case $wupdateOrSnocWithKey $dEq1 lvl26 dt3 dt4 dt1 of { Array dt6 -> Collision dt dt6 } }; Collision dt2 dt3 -> case eqWord# dt dt2 of { __DEFAULT -> $wgoDifferentHash ww dt dt2 wild1 wild2; 1# -> case $wupdateOrConcatWithKey $dEq1 f dt1 dt3 of { Array dt5 -> Collision dt dt5 } } } }; Empty -> w }; } in $wgo 0# eta1 eta2 -- RHS size: {terms: 198, types: 330, coercions: 0, joins: 0/5} $wadjust = \ @ k @ v w w1 w2 w3 -> case hash w w2 of { I# x# -> let { $dEq = $p1Hashable w } in letrec { $wgo = \ ww w4 ww1 w5 -> case w4 of ds { __DEFAULT -> case w5 of wild1 { Empty -> Empty; BitmapIndexed dt dt1 -> let { m = uncheckedShiftL# 1## (word2Int# (and# (uncheckedShiftRL# ww ww1) 31##)) } in case and# dt m of { __DEFAULT -> let { i = word2Int# (popCnt# (and# dt (minusWord# m 1##))) } in case indexSmallArray# dt1 i of { (# ipv #) -> case $wgo ww ds (+# ww1 5#) ipv of vx { __DEFAULT -> case runRW# (\ s1 -> case thawSmallArray# dt1 0# (sizeofSmallArray# dt1) s1 of { (# ipv1, ipv2 #) -> case writeSmallArray# ipv2 i vx ipv1 of s' { __DEFAULT -> case unsafeFreezeSmallArray# ipv2 s' of { (# ipv3, ipv4 #) -> (# ipv3, Array ipv4 #) } } }) of { (# ipv1, ipv2 #) -> case ipv2 of { Array dt3 -> BitmapIndexed dt dt3 } } } }; 0## -> wild1 }; Leaf dt dt1 dt2 -> case eqWord# dt ww of { __DEFAULT -> wild1; 1# -> case == $dEq dt1 ds of { False -> wild1; True -> case w1 dt2 of v1 { __DEFAULT -> Leaf ww ds v1 } } }; Full dt -> let { i = word2Int# (and# (uncheckedShiftRL# ww ww1) 31##) } in case indexSmallArray# dt i of { (# ipv #) -> case $wgo ww ds (+# ww1 5#) ipv of vx { __DEFAULT -> case runRW# (\ s1 -> case thawSmallArray# dt 0# 32# s1 of { (# ipv1, ipv2 #) -> case writeSmallArray# ipv2 i vx ipv1 of s' { __DEFAULT -> case unsafeFreezeSmallArray# ipv2 s' of { (# ipv4, ipv5 #) -> (# ipv4, Array ipv5 #) } } }) of { (# ipv1, ipv2 #) -> $WFull ipv2 } } }; Collision dt dt1 -> case eqWord# ww dt of { __DEFAULT -> wild1; 1# -> case $wupdateWith $dEq w1 ds dt1 of { Array dt3 -> Collision ww dt3 } } } }; } in $wgo (int2Word# x#) w2 0# w3 } -- RHS size: {terms: 12, types: 16, coercions: 0, joins: 0/0} adjust = \ @ k @ v _ w1 w2 w3 w4 -> $wadjust w1 w2 w3 w4 -- RHS size: {terms: 17, types: 32, coercions: 0, joins: 0/0} alterFWeird = \ @ f @ k @ v $dFunctor _ $dHashable _ _ eta2 eta3 eta4 -> $walterFEager $dFunctor $dHashable eta2 eta3 eta4 -- RHS size: {terms: 70, types: 92, coercions: 0, joins: 0/4} $walterF = \ @ f @ k @ v w w1 w2 w3 w4 -> case w3 of k1 { __DEFAULT -> case w4 of m { __DEFAULT -> case hash w1 k1 of { I# x# -> let { $dEq = $p1Hashable w1 } in let { h = int2Word# x# } in let { lvl26 = $wdelete' $dEq h k1 m } in let { mv = case $wlookupRecordCollision# $dEq h k1 m of { (#_|#) ds1 -> Nothing; (#|_#) ds1 -> case ds1 of { (# a, _i #) -> Just a } } } in fmap w (\ fres -> case fres of { Nothing -> case mv of { Nothing -> m; Just x -> lvl26 }; Just v' -> case v' of v'1 { __DEFAULT -> $winsert' $dEq h k1 v'1 m } }) (w2 mv) } } } -- RHS size: {terms: 15, types: 26, coercions: 0, joins: 0/0} alterF = \ @ f @ k @ v w _ w2 w3 w4 w5 -> $walterF w w2 w3 w4 w5 Rec { -- RHS size: {terms: 127, types: 192, coercions: 0, joins: 0/2} $wpoly_go1 = \ @ v @ k ww ww1 w w1 ww2 w2 w3 -> let { x = uncheckedShiftL# 1## (word2Int# (and# (uncheckedShiftRL# ww1 ww) 31##)) } in let { y = uncheckedShiftL# 1## (word2Int# (and# (uncheckedShiftRL# ww2 ww) 31##)) } in case eqWord# x y of { __DEFAULT -> case w of dt2 { __DEFAULT -> case newSmallArray# 2# (Leaf ww1 dt2 w1) w3 of { (# ipv, ipv1 #) -> case <# (word2Int# (and# (uncheckedShiftRL# ww1 ww) 31##)) (word2Int# (and# (uncheckedShiftRL# ww2 ww) 31##)) of { __DEFAULT -> case writeSmallArray# ipv1 0# w2 ipv of s' { __DEFAULT -> case unsafeFreezeSmallArray# ipv1 s' of { (# ipv2, ipv3 #) -> (# ipv2, BitmapIndexed (or# x y) ipv3 #) } }; 1# -> case writeSmallArray# ipv1 1# w2 ipv of s' { __DEFAULT -> case unsafeFreezeSmallArray# ipv1 s' of { (# ipv2, ipv3 #) -> (# ipv2, BitmapIndexed (or# x y) ipv3 #) } } } } }; 1# -> case $wpoly_go1 (+# ww 5#) ww1 w w1 ww2 w2 w3 of { (# ipv, ipv1 #) -> case newSmallArray# 1# ipv1 ipv of { (# ipv2, ipv3 #) -> case unsafeFreezeSmallArray# ipv3 ipv2 of { (# ipv4, ipv5 #) -> (# ipv4, BitmapIndexed x ipv5 #) } } } } end Rec } -- RHS size: {terms: 493, types: 881, coercions: 0, joins: 0/10} $wunsafeInsertWithKey = \ @ k @ v w w1 w2 w3 w4 -> case runRW# (\ w5 -> case hash w w2 of { I# x# -> let { $dEq = $p1Hashable w } in letrec { $s$wgo = \ sc sc1 sc2 sc3 sc4 sc5 sc6 -> case sc5 of k1 { __DEFAULT -> let { m = uncheckedShiftL# 1## (word2Int# (and# (uncheckedShiftRL# sc6 sc3) 31##)) } in let { i = word2Int# (popCnt# (and# sc1 (minusWord# m 1##))) } in case and# sc1 m of { __DEFAULT -> case indexSmallArray# sc2 i of { (# ipv #) -> case $wgo sc6 k1 sc4 (+# sc3 5#) ipv sc of { (# ipv1, ipv2 #) -> case unsafeThawSmallArray# sc2 ipv1 of { (# ipv3, ipv4 #) -> case writeSmallArray# ipv4 i ipv2 ipv3 of s' { __DEFAULT -> case unsafeFreezeSmallArray# ipv4 s' of { (# ipv5, ipv6 #) -> (# ipv5, BitmapIndexed sc1 sc2 #) } } } } }; 0## -> case sc4 of v1 { __DEFAULT -> let { ipv = sizeofSmallArray# sc2 } in case newSmallArray# (+# ipv 1#) undefinedElem sc of { (# ipv1, ipv2 #) -> case copySmallArray# sc2 0# ipv2 0# i ipv1 of s2 { __DEFAULT -> case writeSmallArray# ipv2 i (Leaf sc6 k1 v1) s2 of s' { __DEFAULT -> case copySmallArray# sc2 i ipv2 (+# i 1#) (-# ipv i) s' of s4 { __DEFAULT -> case unsafeFreezeSmallArray# ipv2 s4 of { (# ipv3, ipv4 #) -> case or# sc1 m of wild2 { __DEFAULT -> (# ipv3, BitmapIndexed wild2 ipv4 #); 4294967295## -> (# ipv3, Full ipv4 #) } } } } } } } } }; $wgo = \ ww w6 w7 ww1 w8 w9 -> case w6 of k1 { __DEFAULT -> case w8 of wild1 { Empty -> case w7 of v1 { __DEFAULT -> (# w9, Leaf ww k1 v1 #) }; BitmapIndexed dt dt1 -> let { m = uncheckedShiftL# 1## (word2Int# (and# (uncheckedShiftRL# ww ww1) 31##)) } in let { i = word2Int# (popCnt# (and# dt (minusWord# m 1##))) } in case and# dt m of { __DEFAULT -> case indexSmallArray# dt1 i of { (# ipv #) -> case $wgo ww k1 w7 (+# ww1 5#) ipv w9 of { (# ipv1, ipv2 #) -> case unsafeThawSmallArray# dt1 ipv1 of { (# ipv3, ipv4 #) -> case writeSmallArray# ipv4 i ipv2 ipv3 of s' { __DEFAULT -> case unsafeFreezeSmallArray# ipv4 s' of { (# ipv5, ipv6 #) -> (# ipv5, wild1 #) } } } } }; 0## -> case w7 of v1 { __DEFAULT -> let { ipv = sizeofSmallArray# dt1 } in case newSmallArray# (+# ipv 1#) undefinedElem w9 of { (# ipv1, ipv2 #) -> case copySmallArray# dt1 0# ipv2 0# i ipv1 of s2 { __DEFAULT -> case writeSmallArray# ipv2 i (Leaf ww k1 v1) s2 of s' { __DEFAULT -> case copySmallArray# dt1 i ipv2 (+# i 1#) (-# ipv i) s' of s4 { __DEFAULT -> case unsafeFreezeSmallArray# ipv2 s4 of { (# ipv3, ipv4 #) -> case or# dt m of wild3 { __DEFAULT -> (# ipv3, BitmapIndexed wild3 ipv4 #); 4294967295## -> (# ipv3, Full ipv4 #) } } } } } } } }; Leaf dt dt1 dt2 -> case eqWord# dt ww of { __DEFAULT -> case w7 of x { __DEFAULT -> $wpoly_go1 ww1 ww k1 x dt wild1 w9 }; 1# -> case == $dEq dt1 k1 of { False -> case w7 of x { __DEFAULT -> case runRW# (\ s1 -> case newSmallArray# 2# (L dt1 dt2) s1 of { (# ipv4, ipv5 #) -> case writeSmallArray# ipv5 1# (L k1 x) ipv4 of s' { __DEFAULT -> case unsafeFreezeSmallArray# ipv5 s' of { (# ipv6, ipv7 #) -> (# ipv6, Array ipv7 #) } } }) of { (# ipv4, ipv5 #) -> case ipv5 of { Array dt4 -> (# w9, Collision ww dt4 #) } } }; True -> case w1 k1 w7 dt2 of v1 { __DEFAULT -> (# w9, Leaf ww k1 v1 #) } } }; Full dt -> let { i = word2Int# (and# (uncheckedShiftRL# ww ww1) 31##) } in case indexSmallArray# dt i of { (# ipv #) -> case $wgo ww k1 w7 (+# ww1 5#) ipv w9 of { (# ipv1, ipv2 #) -> case unsafeThawSmallArray# dt ipv1 of { (# ipv3, ipv4 #) -> case writeSmallArray# ipv4 i ipv2 ipv3 of s' { __DEFAULT -> case unsafeFreezeSmallArray# ipv4 s' of { (# ipv5, ipv6 #) -> (# ipv5, wild1 #) } } } } }; Collision dt dt1 -> case eqWord# ww dt of { __DEFAULT -> case runRW# (\ s1 -> case newSmallArray# 1# wild1 s1 of { (# ipv, ipv1 #) -> case unsafeFreezeSmallArray# ipv1 ipv of { (# ipv2, ipv3 #) -> (# ipv2, Array ipv3 #) } }) of { (# ipv, ipv1 #) -> case ipv1 of { Array dt3 -> $s$wgo w9 (uncheckedShiftL# 1## (word2Int# (and# (uncheckedShiftRL# dt ww1) 31##))) dt3 ww1 w7 k1 ww } }; 1# -> case $wupdateOrSnocWithKey $dEq w1 k1 w7 dt1 of { Array dt3 -> (# w9, Collision ww dt3 #) } } } }; } in $wgo (int2Word# x#) w2 w3 0# w4 w5 }) of { (# ipv, ipv1 #) -> ipv1 } -- RHS size: {terms: 14, types: 19, coercions: 0, joins: 0/0} unsafeInsertWithKey = \ @ k @ v _ w1 w2 w3 w4 w5 -> $wunsafeInsertWithKey w1 w2 w3 w4 w5 -- RHS size: {terms: 28, types: 53, coercions: 0, joins: 1/1} fromListWithKey = \ @ k @ v _ $dHashable eta eta1 -> joinrec { go1 ds eta2 = case ds of { [] -> eta2; : y ys -> case y of { (k1, v1) -> jump go1 ys ($wunsafeInsertWithKey $dHashable eta k1 v1 eta2) } }; } in jump go1 eta1 Empty -- RHS size: {terms: 31, types: 57, coercions: 0, joins: 1/2} fromListWith = \ @ k @ v _ $dHashable eta eta1 -> let { lvl26 = \ _ -> eta } in joinrec { go1 ds eta2 = case ds of { [] -> eta2; : y ys -> case y of { (k1, v1) -> jump go1 ys ($wunsafeInsertWithKey $dHashable lvl26 k1 v1 eta2) } }; } in jump go1 eta1 Empty -- RHS size: {terms: 529, types: 1,040, coercions: 0, joins: 0/11} $winsertWith = \ @ k @ v w w1 w2 w3 w4 -> case hash w w2 of { I# x# -> let { lvl26 = \ _ -> w1 } in let { $dEq = $p1Hashable w } in letrec { $s$wgo = \ sc sc1 sc2 sc3 sc4 sc5 -> case sc4 of k1 { __DEFAULT -> let { m = uncheckedShiftL# 1## (word2Int# (and# (uncheckedShiftRL# sc5 sc2) 31##)) } in let { i = word2Int# (popCnt# (and# sc (minusWord# m 1##))) } in case and# sc m of { __DEFAULT -> case indexSmallArray# sc1 i of { (# ipv #) -> case $wgo sc5 k1 sc3 (+# sc2 5#) ipv of vx { __DEFAULT -> case runRW# (\ s1 -> case thawSmallArray# sc1 0# (sizeofSmallArray# sc1) s1 of { (# ipv1, ipv2 #) -> case writeSmallArray# ipv2 i vx ipv1 of s' { __DEFAULT -> case unsafeFreezeSmallArray# ipv2 s' of { (# ipv3, ipv4 #) -> (# ipv3, Array ipv4 #) } } }) of { (# ipv1, ipv2 #) -> case ipv2 of { Array dt1 -> BitmapIndexed sc dt1 } } } }; 0## -> case sc3 of v1 { __DEFAULT -> case runRW# (\ s1 -> let { ipv = sizeofSmallArray# sc1 } in case newSmallArray# (+# ipv 1#) undefinedElem s1 of { (# ipv1, ipv2 #) -> case copySmallArray# sc1 0# ipv2 0# i ipv1 of s2 { __DEFAULT -> case writeSmallArray# ipv2 i (Leaf sc5 k1 v1) s2 of s' { __DEFAULT -> case copySmallArray# sc1 i ipv2 (+# i 1#) (-# ipv i) s' of s4 { __DEFAULT -> case unsafeFreezeSmallArray# ipv2 s4 of { (# ipv3, ipv4 #) -> (# ipv3, Array ipv4 #) } } } } }) of { (# ipv1, ipv2 #) -> case ipv2 of { Array ww1 -> case or# sc m of wild2 { __DEFAULT -> BitmapIndexed wild2 ww1; 4294967295## -> Full ww1 } } } } } }; $wgo = \ ww w5 w6 ww1 w7 -> case w5 of k1 { __DEFAULT -> case w7 of wild1 { Empty -> case w6 of v1 { __DEFAULT -> Leaf ww k1 v1 }; BitmapIndexed dt dt1 -> let { m = uncheckedShiftL# 1## (word2Int# (and# (uncheckedShiftRL# ww ww1) 31##)) } in let { i = word2Int# (popCnt# (and# dt (minusWord# m 1##))) } in case and# dt m of { __DEFAULT -> case indexSmallArray# dt1 i of { (# ipv #) -> case $wgo ww k1 w6 (+# ww1 5#) ipv of vx { __DEFAULT -> case runRW# (\ s1 -> case thawSmallArray# dt1 0# (sizeofSmallArray# dt1) s1 of { (# ipv1, ipv2 #) -> case writeSmallArray# ipv2 i vx ipv1 of s' { __DEFAULT -> case unsafeFreezeSmallArray# ipv2 s' of { (# ipv3, ipv4 #) -> (# ipv3, Array ipv4 #) } } }) of { (# ipv1, ipv2 #) -> case ipv2 of { Array dt3 -> BitmapIndexed dt dt3 } } } }; 0## -> case w6 of v1 { __DEFAULT -> case runRW# (\ s1 -> let { ipv = sizeofSmallArray# dt1 } in case newSmallArray# (+# ipv 1#) undefinedElem s1 of { (# ipv1, ipv2 #) -> case copySmallArray# dt1 0# ipv2 0# i ipv1 of s2 { __DEFAULT -> case writeSmallArray# ipv2 i (Leaf ww k1 v1) s2 of s' { __DEFAULT -> case copySmallArray# dt1 i ipv2 (+# i 1#) (-# ipv i) s' of s4 { __DEFAULT -> case unsafeFreezeSmallArray# ipv2 s4 of { (# ipv3, ipv4 #) -> (# ipv3, Array ipv4 #) } } } } }) of { (# ipv1, ipv2 #) -> case ipv2 of { Array ww3 -> case or# dt m of wild3 { __DEFAULT -> BitmapIndexed wild3 ww3; 4294967295## -> Full ww3 } } } } }; Leaf dt dt1 dt2 -> case eqWord# dt ww of { __DEFAULT -> case w6 of x { __DEFAULT -> case runRW# (\ w8 -> $wpoly_go1 ww1 ww k1 x dt wild1 w8) of { (# ipv, ipv1 #) -> ipv1 } }; 1# -> case == $dEq dt1 k1 of { False -> case w6 of x { __DEFAULT -> case runRW# (\ s1 -> case newSmallArray# 2# (L dt1 dt2) s1 of { (# ipv4, ipv5 #) -> case writeSmallArray# ipv5 1# (L k1 x) ipv4 of s' { __DEFAULT -> case unsafeFreezeSmallArray# ipv5 s' of { (# ipv6, ipv7 #) -> (# ipv6, Array ipv7 #) } } }) of { (# ipv4, ipv5 #) -> case ipv5 of { Array dt4 -> Collision ww dt4 } } }; True -> case w1 w6 dt2 of v1 { __DEFAULT -> Leaf ww k1 v1 } } }; Full dt -> let { i = word2Int# (and# (uncheckedShiftRL# ww ww1) 31##) } in case indexSmallArray# dt i of { (# ipv #) -> case $wgo ww k1 w6 (+# ww1 5#) ipv of vx { __DEFAULT -> case runRW# (\ s1 -> case thawSmallArray# dt 0# 32# s1 of { (# ipv1, ipv2 #) -> case writeSmallArray# ipv2 i vx ipv1 of s' { __DEFAULT -> case unsafeFreezeSmallArray# ipv2 s' of { (# ipv4, ipv5 #) -> (# ipv4, Array ipv5 #) } } }) of { (# ipv1, ipv2 #) -> $WFull ipv2 } } }; Collision dt dt1 -> case eqWord# ww dt of { __DEFAULT -> case runRW# (\ s1 -> case newSmallArray# 1# wild1 s1 of { (# ipv, ipv1 #) -> case unsafeFreezeSmallArray# ipv1 ipv of { (# ipv2, ipv3 #) -> (# ipv2, Array ipv3 #) } }) of { (# ipv, ipv1 #) -> case ipv1 of { Array dt3 -> $s$wgo (uncheckedShiftL# 1## (word2Int# (and# (uncheckedShiftRL# dt ww1) 31##))) dt3 ww1 w6 k1 ww } }; 1# -> case $wupdateOrSnocWithKey $dEq lvl26 k1 w6 dt1 of { Array dt3 -> Collision ww dt3 } } } }; } in $wgo (int2Word# x#) w2 w3 0# w4 } -- RHS size: {terms: 14, types: 18, coercions: 0, joins: 0/0} insertWith = \ @ k @ v _ w1 w2 w3 w4 w5 -> $winsertWith w1 w2 w3 w4 w5 -- RHS size: {terms: 2, types: 0, coercions: 0, joins: 0/0} $trModule3 = TrNameS $trModule4 -- RHS size: {terms: 2, types: 0, coercions: 0, joins: 0/0} $trModule1 = TrNameS $trModule2 -- RHS size: {terms: 3, types: 0, coercions: 0, joins: 0/0} $trModule = Module $trModule3 $trModule1 ------ Local rules for imported ids -------- "alterFlookup" forall @ k @ a @ r $dFunctor $dEq $dHashable _ign1 _ign2 f. alterFWeird $dFunctor $dEq $dHashable _ign1 _ign2 f = let { $dEq1 = $p1Hashable $dHashable } in \ k1 m -> case k1 of k2 { __DEFAULT -> case m of m1 { __DEFAULT -> (getConst (f (lookup $dEq1 $dHashable k2 m1))) `cast` } } "alterFadjust" forall @ k @ a @ a1 @ a2 $dFunctor $dEq $dHashable $r$dCoercible $r$dCoercible1 f x. alterFWeird $dFunctor $dEq $dHashable (Nothing `cast` ) ((Just x) `cast` ) f = (adjust ($p1Hashable $dHashable) $dHashable (\ a3 -> case runIdentity (f (Just a3)) of { Nothing -> impossibleAdjust; Just a' -> a' })) `cast` "alterFinsertWith" [1] forall @ k @ a @ a1 $dFunctor $dEq $dHashable $r$dCoercible $r$dCoercible1 f x y. alterFWeird $dFunctor $dEq $dHashable ((Just x) `cast` ) ((Just y) `cast` ) f = (insertModifying ($p1Hashable $dHashable) $dHashable x (\ mold -> case runIdentity (f (Just mold)) of { Nothing -> bogus# (##); Just new -> case new of new1 { __DEFAULT -> (# new1 #) } })) `cast` "alterFconstant" forall @ k @ a $dFunctor $dEq $dHashable f x. alterFWeird $dFunctor $dEq $dHashable x x f = let { $dEq1 = $p1Hashable $dHashable } in \ k1 m -> case k1 of k2 { __DEFAULT -> case m of m1 { __DEFAULT -> case runIdentity x of { Nothing -> (delete $dEq1 $dHashable k2 m1) `cast` ; Just a1 -> (insert $dEq1 $dHashable k2 a1 m1) `cast` } } } "alterFWeird" forall @ k @ v @ f $dFunctor $dEq $dHashable f1. alterF $dFunctor $dEq $dHashable f1 = alterFWeird $dFunctor ($p1Hashable $dHashable) $dHashable (f1 Nothing) (f1 (Just test_bottom)) f1