Created
June 24, 2018 14:45
-
-
Save bergmark/7f4f816680457e55a07468e27d988f38 to your computer and use it in GitHub Desktop.
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Magic: Wanted 33214052, | |
| got 33214052 | |
| Version: Wanted [8, 0, 4, 3], | |
| got [8, 0, 4, 3] | |
| Way: Wanted [], | |
| got [] | |
| interface Data.Aeson.Parser.Internal 8043 | |
| interface hash: 6c48b91f954a886667298160132ec1f5 | |
| ABI hash: cbc607c318f4c74423c0c6c39b768837 | |
| export-list hash: b58d6e2302b000257458873f6a7faddd | |
| orphan hash: 693e9af84d3dfcc71e640e005bdc5e2e | |
| flag hash: 5f7fd52ecc3a8cbc4feaf4a209642cd3 | |
| opt_hash: 2c98c95d41c045ae9c2fb565ec8aabc6 | |
| hpc_hash: 93b885adfe0da089cdf634904fd59f71 | |
| sig of: Nothing | |
| used TH splices: False | |
| where | |
| exports: | |
| decodeStrictWith | |
| decodeWith | |
| eitherDecodeStrictWith | |
| eitherDecodeWith | |
| json | |
| json' | |
| jsonEOF | |
| jsonEOF' | |
| jstring | |
| jstring_ | |
| scientific | |
| value | |
| value' | |
| module dependencies: Data.Aeson.Parser.Unescape | |
| Data.Aeson.Parser.UnescapePure Data.Aeson.Types.Internal | |
| package dependencies: array-0.5.2.0 | |
| attoparsec-0.13.2.2-7134042ae4a8825e0220e72bbc50a3aea433895ec2d42a68a9d57176061e3182 | |
| base-4.11.1.0 | |
| base-compat-0.10.1-1ef699a6203a06e0dc43e61f984660eaee898b80a1675f162f90048d122ea0f5 | |
| binary-0.8.5.1 bytestring-0.10.8.2 containers-0.5.11.0 | |
| deepseq-1.4.3.0 ghc-boot-th-8.4.3 ghc-prim-0.5.2.0 | |
| hashable-1.2.7.0-dcc6e7516fee6fec23dcb1e670f534954750710d87259d7927d7ee0fbc2873c4 | |
| integer-gmp-1.0.2.0 | |
| integer-logarithms-1.0.2.1-9cb065341b0c4a126d1050ccdb483b72c50971ce446aeba53fd5e098a9885dae | |
| primitive-0.6.4.0-3395770b3ed84d44d523a9eb5134a825e3e188f2c348d1e21915dda5e2b04fc0 | |
| scientific-0.3.6.2-fcc2083045e5559daae557497794d5767b3e81796733354d5f13ddc5130a53d2 | |
| template-haskell-2.13.0.0 text-1.2.3.0 time-1.8.0.2 | |
| transformers-0.5.5.0 | |
| unordered-containers-0.2.9.0-928d5897b2b2865d22ddbb1d8b9c168c9c1ef9c600793a7041129e65381db7be | |
| vector-0.12.0.1-70c8f4ca14044072bf9c125f86cf63d6f8f86ae0b158fafc189693e1b9d3afc8 | |
| orphans: Data.Time.Format.Parse | |
| Data.Time.LocalTime.Internal.ZonedTime | |
| Data.Time.LocalTime.Internal.LocalTime Data.Time.Calendar.Gregorian | |
| Data.Attoparsec.ByteString.Char8 Data.Vector.Fusion.Bundle | |
| Data.Hashable.Generic Control.Monad.Trans.Error Data.Text.Lazy | |
| Data.Text Data.Binary.Generic Data.Text.Show | |
| Data.ByteString.Builder GHC.Float GHC.Base | |
| family instance modules: Data.Aeson.Types.Internal | |
| Data.Attoparsec.Internal.Types Control.Applicative Data.Complex | |
| Data.Functor.Compose Data.Functor.Const Data.Functor.Identity | |
| Data.Functor.Product Data.Functor.Sum Data.Monoid Data.Semigroup | |
| Data.Semigroup.Internal Data.Version Data.Void GHC.Exts | |
| GHC.Generics GHC.IO.Exception Data.IntMap.Internal | |
| Data.IntSet.Internal Data.Map.Internal Data.Sequence.Internal | |
| Data.Set.Internal Data.Tree GHC.ForeignSrcLang.Type | |
| GHC.LanguageExtensions.Type Control.Monad.Primitive | |
| Data.Primitive.Array Language.Haskell.TH.Syntax Data.Text | |
| Data.Text.Lazy Data.HashMap.Base Data.Vector | |
| import -/ Data.Aeson.Parser.Unescape 6e27f9fc5ccfb24d22454945fdecac13 | |
| exports: 3774ad0637785081e3fb02acab047226 | |
| import -/ Data.Aeson.Parser.UnescapePure c48b70273c8bf802e2948441c464208c | |
| unescapeText cf59aa5f710f3befe0ae1a07d249557f | |
| import -/ Data.Aeson.Types.Internal 51d2e81f2d2bc067f5cb104457311cef | |
| exports: c94b5ea379b87d7ec06dde41e655e60e | |
| Array a11d6bd6ebee74d9f4e93ab941b67de9 | |
| Bool ddd4aca69c7a749469da3094fae03ea5 | |
| Error d20b9a361a67e84c3fd5605517f3fba7 | |
| IError bd274df60101bcd6cc0bf10c8a165c3d | |
| IResult 2df035a6744d9f202cac1bebd3fd9967 | |
| ISuccess 1c8f209bac4db0f5eb1b2d0fb4b4ad88 | |
| JSONPath dbbe5f757f985630088761c3e97a8ec8 | |
| Null 8dc09934817c710142998895f31cbd2c | |
| Number 3bb0fbb8c93aaf686445426c297393fa | |
| Object 4afe70447d4795b3bdb304db6c49b8f0 | |
| Result e6f31a8f5330677f43bc4800b04c569f | |
| String 4513208ac7785b86c3f49f4e6d2ec3c4 | |
| Success 287e3c7e6aba54f97c4cdb0e65db4058 | |
| Value 878289cc53c46e7d0ecf6427bca425a9 | |
| import -/ Data.Attoparsec.ByteString 6ac2f09a80db251647027a1ab4fce149 | |
| import -/ Data.Attoparsec.ByteString.Char8 92847459b2164ad403511d0f6a5423ba | |
| import -/ Data.Attoparsec.ByteString.Internal 15305ab208295fff8a7836ca3afb336b | |
| import -/ Data.Attoparsec.ByteString.Lazy 7c248930a16c35cfabbb443253a79f62 | |
| import -/ Data.Attoparsec.Internal 178748a7ae7a28936ce5ea138e3f34fa | |
| import -/ Data.Attoparsec.Lazy d2db1f599e3adb0e7fbb931cb50f5c7c | |
| import -/ Control.Applicative 55d9b3a7491623b0362290e162d67308 | |
| import -/ Control.Monad c5f960c67d822497578bffbd3e4c01cf | |
| import -/ Data.Either 39d922b371c4c52d426e9ee66de8371a | |
| import -/ Data.Functor f522c3501272159820fd6f242510732f | |
| import -/ GHC.Base 604111500e81281298777e721c75643b | |
| import -/ GHC.Num 8e54b26dce4495382dc4b50cf36ab754 | |
| import -/ GHC.Real b4beb0389ba1ad5d9640aae67848c5d3 | |
| import -/ GHC.Show 73be67392447c974f19c3befd83c46c0 | |
| import -/ GHC.Word bc9bdf9b61a0f9352e5a1baeee5690a5 | |
| import -/ Prelude 0750c25585e2b797cd78291d423d39dd | |
| import -/ Prelude.Compat b78996950e9cb6040ba5ca05fd9061c0 | |
| import -/ Data.ByteString 6d0008c12e5c3acd7278a6b95640b4e2 | |
| import -/ Data.ByteString.Internal dc7d0c96ef45c703ca21607112260299 | |
| import -/ Data.ByteString.Lazy b6cb59a78204810b2a79502bf5b4c1fc | |
| import -/ Data.ByteString.Lazy.Internal af245ead1f52eca50149d040b0b86693 | |
| import -/ Data.ByteString.Unsafe 2222669b7c2e1b00b40de42cb0082c7e | |
| import -/ GHC.Classes 122abfcd7450c6c11602933c9ca5f80d | |
| import -/ GHC.Types d9b3023de7feae4a5308d643da5543f7 | |
| import -/ GHC.Integer.Type f3d5169c3d3830854b19f6565b265403 | |
| import -/ Data.Scientific 3a026c43483a00f821eb420da6e5c6d6 | |
| import -/ Data.Text 7daa7e6c9b39d8cc1679e5ec5c64d2be | |
| import -/ Data.Text.Encoding 8e60367b574d8e5016309aaea7dc2100 | |
| import -/ Data.Text.Internal 30a0a123f71f63b26cd34c6b24f23411 | |
| import -/ Data.HashMap.Base d02a1394c38ff7ad20dfcecf12922e71 | |
| import -/ Data.HashMap.Strict b74da9a21c1729ebedc927c2ce70001b | |
| import -/ Data.Vector b68ddb95e14018bfb491b397ec93b45b | |
| addDependentFile "/Users/adam/ghc/8.4.3/lib/ghc-8.4.3/include/ghcversion.h" 61cc4580d32de09862d412848a79cd26 | |
| addDependentFile "/Users/adam/repos/hs/aeson/dist-newstyle/build/x86_64-osx/ghc-8.4.3/aeson-1.4.0.0/build/autogen/cabal_macros.h" c22dce529cb038350b482e00597882ae | |
| 4580007b941c00288cf89559cee3d671 | |
| $sunsafeInsert_$s$wpoly_go1 :: | |
| State# RealWorld | |
| -> Word# | |
| -> SmallArray# (HashMap Text v) | |
| -> Int# | |
| -> v | |
| -> Int# | |
| -> Int# | |
| -> ByteArray# | |
| -> Word# | |
| -> (# State# RealWorld, HashMap Text v #) | |
| {- Arity: 9, | |
| Strictness: <S,U><S,U><S,U><S,U><L,U><L,U><L,U><L,U><S,U> -} | |
| 0b74e96aaa38cfe01dfaacfca3994090 | |
| $tc'S :: TyCon | |
| {- HasNoCafRefs, Strictness: m, | |
| Unfolding: (TyCon | |
| 15904816974497928696## | |
| 3405016299909475310## | |
| $trModule | |
| $tc'S2 | |
| 0# | |
| $tc'S1) -} | |
| f581e1a5626df19c7f5c9a79d23fe30e | |
| $tc'S1 :: KindRep | |
| {- HasNoCafRefs, Strictness: m4, Inline: [~] -} | |
| 923e1fbcadfdc547aedfb7941869d280 | |
| $tc'S2 :: TrName | |
| {- HasNoCafRefs, Strictness: m1, Unfolding: (TrNameS $tc'S3) -} | |
| aa71459d23c1eb6dd07e32992da1c06e | |
| $tc'S3 :: Addr# | |
| {- HasNoCafRefs, Unfolding: ("'S"#) -} | |
| b933e47f6c388c1b50a13bb90d9855f7 | |
| $tc'SP :: TyCon | |
| {- HasNoCafRefs, Strictness: m, | |
| Unfolding: (TyCon | |
| 2804492806601239899## | |
| 8199699193557681475## | |
| $trModule | |
| $tc'SP2 | |
| 0# | |
| $tc'SP1) -} | |
| e90cc74e8f453a2c296d8f0526004ee7 | |
| $tc'SP1 :: KindRep | |
| {- HasNoCafRefs, Strictness: m4, Inline: [~] -} | |
| 2a1c47138625ebd25bbad8771d3dadee | |
| $tc'SP2 :: TrName | |
| {- HasNoCafRefs, Strictness: m1, Unfolding: (TrNameS $tc'SP3) -} | |
| 0e4ec9a224b4961cbbf437e4c88afc2d | |
| $tc'SP3 :: Addr# | |
| {- HasNoCafRefs, Unfolding: ("'SP"#) -} | |
| bf57b5ba36c3153b9d96aaf0da53c32e | |
| $tcS :: TyCon | |
| {- HasNoCafRefs, Strictness: m, | |
| Unfolding: (TyCon | |
| 17386818347632118270## | |
| 8047096446631111941## | |
| $trModule | |
| $tcS1 | |
| 0# | |
| krep$*) -} | |
| 1e5dffa566874245ef25e0c050a7a37c | |
| $tcS1 :: TrName | |
| {- HasNoCafRefs, Strictness: m1, Unfolding: (TrNameS $tcS2) -} | |
| 507a3886ba987ca06d81f0906e9ff5a7 | |
| $tcS2 :: Addr# | |
| {- HasNoCafRefs, Unfolding: ("S"#) -} | |
| e999eeca7064e821816e417f627719b0 | |
| $tcSP :: TyCon | |
| {- HasNoCafRefs, Strictness: m, | |
| Unfolding: (TyCon | |
| 6315595159143346274## | |
| 16415830346009778649## | |
| $trModule | |
| $tcSP1 | |
| 0# | |
| krep$*) -} | |
| 162aac09bfa2764ea4e924d8a81f6d39 | |
| $tcSP1 :: TrName | |
| {- HasNoCafRefs, Strictness: m1, Unfolding: (TrNameS $tcSP2) -} | |
| 2e06824249b08f8f43772dff051f51ec | |
| $tcSP2 :: Addr# | |
| {- HasNoCafRefs, Unfolding: ("SP"#) -} | |
| 15090e3e5ce222ff454992d276eefc42 | |
| $trModule :: Module | |
| {- HasNoCafRefs, Strictness: m, | |
| Unfolding: (Module $trModule3 $trModule1) -} | |
| ebd5eaa7e9281640239c14252ea7d8bf | |
| $trModule1 :: TrName | |
| {- HasNoCafRefs, Strictness: m1, Unfolding: (TrNameS $trModule2) -} | |
| b97a7a3c0358a1f4ae89490709788462 | |
| $trModule2 :: Addr# | |
| {- HasNoCafRefs, Unfolding: ("Data.Aeson.Parser.Internal"#) -} | |
| 0783cc2e15105019e5ecd606b9fd4607 | |
| $trModule3 :: TrName | |
| {- HasNoCafRefs, Strictness: m1, Unfolding: (TrNameS $trModule4) -} | |
| a57b622962642cd2709ca7b1082ba9c5 | |
| $trModule4 :: Addr# | |
| {- HasNoCafRefs, Unfolding: ("aeson-1.4.0.0-inplace"#) -} | |
| 17b2bcfc7de3ef4a460a00587755e36c | |
| $w$s$wupdateOrSnocWithKey :: | |
| (Text -> v -> v -> v) | |
| -> ByteArray# | |
| -> Int# | |
| -> Int# | |
| -> v | |
| -> Array# (Leaf Text v) | |
| -> Array (Leaf Text v) | |
| {- Arity: 6, Strictness: <L,C(C1(C1(U)))><S,U><S,U><S,U><L,U><S,U>, | |
| Inline: [0], | |
| Unfolding: (\ @ v2 | |
| (w :: Text -> v2 -> v2 -> v2) | |
| (ww :: ByteArray#) | |
| (ww1 :: Int#) | |
| (ww2 :: Int#) | |
| (w1 :: v2) | |
| (w2 :: Array# (Leaf Text v2)) -> | |
| let { | |
| exit :: v2 | |
| -> Array# (Leaf Text v2) | |
| -> Int# | |
| -> Text | |
| -> v2 | |
| -> Array (Leaf Text v2) | |
| <join 5> {- Arity: 5, Strictness: <L,U><S,U><S,U><L,U><L,U> -} | |
| = \ (w3 :: v2)[OneShot] | |
| (ww3 :: Array# (Leaf Text v2))[OneShot] | |
| (ww4 :: Int#)[OneShot] | |
| (k2 :: Text)[OneShot] | |
| (y :: v2)[OneShot] -> | |
| case runRW# | |
| @ ('TupleRep '['TupleRep '[], 'LiftedRep]) | |
| @ (# State# RealWorld, Array (Leaf Text v2) #) | |
| (\ (s1 :: State# RealWorld)[OneShot] -> | |
| case thawSmallArray# | |
| @ (Leaf Text v2) | |
| @ RealWorld | |
| ww3 | |
| 0# | |
| (sizeofSmallArray# @ (Leaf Text v2) ww3) | |
| s1 of ds2 { (#,#) ipv4 ipv5 -> | |
| case writeSmallArray# | |
| @ RealWorld | |
| @ (Leaf Text v2) | |
| ipv5 | |
| ww4 | |
| (L @ Text @ v2 k2 (w k2 w3 y)) | |
| ipv4 of s' { DEFAULT -> | |
| case unsafeFreezeSmallArray# | |
| @ RealWorld | |
| @ (Leaf Text v2) | |
| ipv5 | |
| s' of ds3 { (#,#) ipv6 ipv7 -> | |
| (# ipv6, | |
| Array @ (Leaf Text v2) ipv7 #) } } }) of ds2 { (#,#) ipv4 ipv5 -> | |
| ipv5 } | |
| } in | |
| letrec { | |
| $wgo7 :: ByteArray# | |
| -> Int# | |
| -> Int# | |
| -> v2 | |
| -> Array# (Leaf Text v2) | |
| -> Int# | |
| -> Int# | |
| -> Array (Leaf Text v2) | |
| <join 7> {- Arity: 7, | |
| Strictness: <L,U><L,U><L,U><L,U><S,U><S,U><S,U>, Inline: [0] -} | |
| = \ (ww3 :: ByteArray#) | |
| (ww4 :: Int#) | |
| (ww5 :: Int#) | |
| (w3 :: v2) | |
| (ww6 :: Array# (Leaf Text v2)) | |
| (ww7 :: Int#) | |
| (ww8 :: Int#) -> | |
| case >=# ww7 ww8 of lwild { | |
| DEFAULT | |
| -> case indexSmallArray# | |
| @ (Leaf Text v2) | |
| ww6 | |
| ww7 of ds1 { Unit# ipv3 -> | |
| case ipv3 of wild { L kx y -> | |
| case kx of wild1 { Text dt3 dt4 dt5 -> | |
| case ==# ww5 dt5 of lwild1 { | |
| DEFAULT -> $wgo7 ww3 ww4 ww5 w3 ww6 (+# ww7 1#) ww8 | |
| 1# | |
| -> case {__pkg_ccall text-1.2.3.0 ByteArray# | |
| -> Word# | |
| -> ByteArray# | |
| -> Word# | |
| -> Word# | |
| -> State# RealWorld | |
| -> (# State# RealWorld, Int# #)} | |
| ww3 | |
| (int2Word# ww4) | |
| dt3 | |
| (int2Word# dt4) | |
| (int2Word# ww5) | |
| realWorld# of wild5 { (#,#) ds2 ds3 -> | |
| case narrow32Int# ds3 of wild2 { | |
| DEFAULT -> $wgo7 ww3 ww4 ww5 w3 ww6 (+# ww7 1#) ww8 | |
| 0# -> exit w3 ww6 ww7 (Text ww3 ww4 ww5) y } } } } } } | |
| 1# | |
| -> case runRW# | |
| @ ('TupleRep '['TupleRep '[], 'LiftedRep]) | |
| @ (# State# RealWorld, Array (Leaf Text v2) #) | |
| (\ (s1 :: State# RealWorld)[OneShot] -> | |
| case newSmallArray# | |
| @ (Leaf Text v2) | |
| @ RealWorld | |
| (+# ww8 1#) | |
| (undefinedElem @ (Leaf Text v2)) | |
| s1 of ds { (#,#) ipv3 ipv4 -> | |
| case copySmallArray# | |
| @ (Leaf Text v2) | |
| @ RealWorld | |
| ww6 | |
| 0# | |
| ipv4 | |
| 0# | |
| ww8 | |
| ipv3 of s2 { DEFAULT -> | |
| case writeSmallArray# | |
| @ RealWorld | |
| @ (Leaf Text v2) | |
| ipv4 | |
| ww8 | |
| (L @ Text @ v2 (Text ww3 ww4 ww5) w3) | |
| s2 of s' { DEFAULT -> | |
| case unsafeFreezeSmallArray# | |
| @ RealWorld | |
| @ (Leaf Text v2) | |
| ipv4 | |
| s' of ds2 { (#,#) ipv5 ipv6 -> | |
| (# ipv5, | |
| Array | |
| @ (Leaf Text v2) | |
| ipv6 #) } } } }) of ds1 { (#,#) ipv3 ipv4 -> | |
| ipv4 } } | |
| } in | |
| $wgo7 | |
| ww | |
| ww1 | |
| ww2 | |
| w1 | |
| w2 | |
| 0# | |
| (sizeofSmallArray# @ (Leaf Text v2) w2)) -} | |
| 345e409fc163c9cbafb46283118d843a | |
| $w$sunsafeInsert :: | |
| ByteArray# -> Int# -> Int# -> v -> HashMap Text v -> HashMap Text v | |
| {- Arity: 5, Strictness: <S,U><S,U><S,U><L,U><L,1*U>, Inline: [0], | |
| Unfolding: (\ @ v2 | |
| (ww :: ByteArray#) | |
| (ww1 :: Int#) | |
| (ww2 :: Int#) | |
| (w :: v2) | |
| (w1 :: HashMap Text v2) -> | |
| case runRW# | |
| @ ('TupleRep '['TupleRep '[], 'LiftedRep]) | |
| @ (# State# RealWorld, HashMap Text v2 #) | |
| (\ (w2 :: State# RealWorld)[OneShot] -> | |
| case {__pkg_ccall hashable-1.2.7.0-dcc6e7516fee6fec23dcb1e670f534954750710d87259d7927d7ee0fbc2873c4 ByteArray# | |
| -> Int# | |
| -> Int# | |
| -> Int# | |
| -> State# | |
| RealWorld | |
| -> (# State# | |
| RealWorld, | |
| Int# #)} | |
| ww | |
| (uncheckedIShiftL# ww1 1#) | |
| (uncheckedIShiftL# ww2 1#) | |
| -2578643520546668380# | |
| realWorld# of wild1 { (#,#) ds1 ds2 -> | |
| $wpoly_go1 | |
| @ v2 | |
| (int2Word# ds2) | |
| ww | |
| ww1 | |
| ww2 | |
| w | |
| 0# | |
| w1 | |
| w2 }) of ds1 { (#,#) ipv ipv1 -> | |
| ipv1 }) -} | |
| b61e1e1a3a5880895b570c0d3733c1ba | |
| $wdecimal0 :: | |
| Addr# | |
| -> ForeignPtrContents | |
| -> Int# | |
| -> Int# | |
| -> Int# | |
| -> Int# | |
| -> Int# | |
| -> More | |
| -> Failure ByteString (State ByteString) r | |
| -> Success ByteString (State ByteString) Integer r | |
| -> IResult ByteString r | |
| {- Arity: 10, | |
| Strictness: <L,U><L,U><L,U><S,U><L,U><L,U><S,U><L,U><L,C(C1(C1(C1(C1(U)))))><L,C(C1(C1(C1(U))))>, | |
| Inline: [0] -} | |
| 41caef02a499f6a55469ba394ace3a33 | |
| $wgo :: | |
| Addr# | |
| -> ForeignPtrContents | |
| -> Int# | |
| -> Int# | |
| -> Int# | |
| -> Int# | |
| -> Int# | |
| -> More | |
| -> Success ByteString (State ByteString) () r | |
| -> IResult ByteString r | |
| {- Arity: 9, | |
| Strictness: <S,U><L,U><S,U><S,U><L,U><L,U><S,U><L,U><L,C(C1(C1(C1(U))))>, | |
| Inline: [0] -} | |
| 321dafa925d4a11cf529dd7bc0fcebf7 | |
| $wjsonEOF :: | |
| Addr# | |
| -> ForeignPtrContents | |
| -> Int# | |
| -> Int# | |
| -> Int# | |
| -> Int# | |
| -> Int# | |
| -> More | |
| -> Failure ByteString (State ByteString) r | |
| -> Success ByteString (State ByteString) Value r | |
| -> IResult ByteString r | |
| {- Arity: 10, | |
| Strictness: <S,U><L,U><S,U><S,U><S,U><S,U><S,U><L,U><L,C(C1(C1(C1(C1(U)))))><L,C(C1(C1(C1(U))))>, | |
| Inline: [0], | |
| Unfolding: (\ @ r | |
| (ww :: Addr#) | |
| (ww1 :: ForeignPtrContents) | |
| (ww2 :: Int#) | |
| (ww3 :: Int#) | |
| (ww4 :: Int#) | |
| (ww5 :: Int#) | |
| (ww6 :: Int#) | |
| (w :: More) | |
| (w1 :: Failure ByteString (State ByteString) r) | |
| (w2 :: Success ByteString (State ByteString) Value r) -> | |
| $wvalue | |
| @ r | |
| ww | |
| ww1 | |
| ww2 | |
| ww3 | |
| ww4 | |
| ww5 | |
| ww6 | |
| w | |
| w1 | |
| (\ (t' :: State ByteString) | |
| (pos' :: Pos)[OneShot] | |
| (more' :: More)[OneShot] | |
| (a1 :: Value)[OneShot] -> | |
| case t' | |
| `cast` | |
| (Sub (D:R:StateByteString[0])) of ww7 { Buf ww8 ww9 ww10 ww11 ww12 ww13 -> | |
| case pos' `cast` (N:Pos[0]) of ww14 { I# ww15 -> | |
| let { | |
| lvl43 :: State ByteString | |
| -> Pos -> More -> () -> IResult ByteString r | |
| {- Arity: 4, Strictness: <L,U><S,1*U(U)><L,U><L,A>, | |
| Unfolding: InlineRule (4, True, False) | |
| (\ (t'1 :: State ByteString)[OneShot] | |
| (pos'1 :: Pos)[OneShot] | |
| (more'1 :: More)[OneShot] | |
| (a2 :: ())[OneShot] -> | |
| case pos'1 `cast` (N:Pos[0]) of nt2 { I# ipv2 -> | |
| w2 t'1 nt2 `cast` (Sym (N:Pos[0])) more'1 a1 }) -} | |
| = \ (t'1 :: State ByteString)[OneShot] | |
| (pos'1 :: Pos)[OneShot] | |
| (more'1 :: More)[OneShot] | |
| (a2 :: ())[OneShot] -> | |
| case pos'1 `cast` (N:Pos[0]) of nt2 { I# ipv2 -> | |
| w2 t'1 nt2 `cast` (Sym (N:Pos[0])) more'1 a1 } | |
| } in | |
| $wgo | |
| @ r | |
| ww8 | |
| ww9 | |
| ww10 | |
| ww11 | |
| ww12 | |
| ww13 | |
| ww15 | |
| more' | |
| (\ (t'1 :: State ByteString) | |
| (pos'1 :: Pos)[OneShot] | |
| (more'1 :: More)[OneShot] | |
| (a2 :: ())[OneShot] -> | |
| case pos'1 `cast` (N:Pos[0]) of nt2 { I# ipv2 -> | |
| $wendOfInput | |
| @ ByteString | |
| $fChunkByteString | |
| @ r | |
| t'1 | |
| ipv2 | |
| more'1 | |
| w1 | |
| lvl43 }) } })) -} | |
| 04145c7135ba1d58e04ed9a30f747eb0 | |
| $wjsonEOF' :: | |
| Addr# | |
| -> ForeignPtrContents | |
| -> Int# | |
| -> Int# | |
| -> Int# | |
| -> Int# | |
| -> Int# | |
| -> More | |
| -> Failure ByteString (State ByteString) r | |
| -> Success ByteString (State ByteString) Value r | |
| -> IResult ByteString r | |
| {- Arity: 10, | |
| Strictness: <S,U><L,U><S,U><S,U><S,U><S,U><S,U><L,U><L,C(C1(C1(C1(C1(U)))))><L,C(C1(C1(C1(U))))>, | |
| Inline: [0] -} | |
| 8b70e68f882f13076a8bd1867dfcff62 | |
| $wjstring :: | |
| Addr# | |
| -> ForeignPtrContents | |
| -> Int# | |
| -> Int# | |
| -> Int# | |
| -> Int# | |
| -> Int# | |
| -> More | |
| -> Failure ByteString (State ByteString) r | |
| -> Success ByteString (State ByteString) Text r | |
| -> IResult ByteString r | |
| {- Arity: 10, | |
| Strictness: <L,U><L,U><L,U><S,U><L,U><L,U><S,U><L,U><L,C(C1(C1(C1(C1(U)))))><L,C(C1(C1(C1(U))))>, | |
| Inline: [0] -} | |
| 8233c24a26031932830afdf94760cd9e | |
| $wpoly_go1 :: | |
| Word# | |
| -> ByteArray# | |
| -> Int# | |
| -> Int# | |
| -> v | |
| -> Int# | |
| -> HashMap Text v | |
| -> State# RealWorld | |
| -> (# State# RealWorld, HashMap Text v #) | |
| {- Arity: 8, | |
| Strictness: <L,U><L,U><L,U><L,U><L,U><L,U><S,1*U><L,U>, | |
| Inline: [0] -} | |
| a7334e8a0435baeb71522f1c600176ee | |
| $wvalue :: | |
| Addr# | |
| -> ForeignPtrContents | |
| -> Int# | |
| -> Int# | |
| -> Int# | |
| -> Int# | |
| -> Int# | |
| -> More | |
| -> Failure ByteString (State ByteString) r | |
| -> Success ByteString (State ByteString) Value r | |
| -> IResult ByteString r | |
| {- Arity: 10, | |
| Strictness: <S,U><L,U><S,U><S,U><S,U><S,U><S,U><L,U><L,C(C1(C1(C1(C1(U)))))><L,C(C1(C1(C1(U))))>, | |
| Inline: [0] -} | |
| 06531982f30ed0f38cf82e72c4fe26e5 | |
| $wvalue' :: | |
| Addr# | |
| -> ForeignPtrContents | |
| -> Int# | |
| -> Int# | |
| -> Int# | |
| -> Int# | |
| -> Int# | |
| -> More | |
| -> Failure ByteString (State ByteString) r | |
| -> Success ByteString (State ByteString) Value r | |
| -> IResult ByteString r | |
| {- Arity: 10, | |
| Strictness: <S,U><L,U><S,U><S,U><L,U><L,U><S,U><L,U><L,C(C1(C1(C1(C1(U)))))><L,C(C1(C1(C1(U))))>, | |
| Inline: [0] -} | |
| 14eb228b4f89a4dec22adb3a63957675 | |
| data S = S Int# Int# | |
| 518c7a82999b71585aa9f3fa4781f8a5 | |
| data SP = SP !Integer {-# UNPACK #-}Int | |
| e234d5a93284ef5e34aedd571c226a3e | |
| decodeStrictWith :: | |
| Parser Value -> (Value -> Result a) -> ByteString -> Maybe a | |
| {- Arity: 3, | |
| Strictness: <C(C(C(C(C(S))))),1*C1(C1(C1(C1(C1(U)))))><L,1*C1(U)><L,1*U(U,U,U,U)>, | |
| Inline: (sat-args=3), | |
| Unfolding: InlineRule (3, False, False) | |
| (\ @ a | |
| (p :: Parser Value) | |
| (to :: Value -> Result a) | |
| (s :: ByteString) -> | |
| case p `cast` (N:Parser[0] <ByteString>_N <Value>_R) | |
| @ Value | |
| (buffer s) `cast` (Sub (Sym (D:R:StateByteString[0]))) | |
| (I# 0#) `cast` (Sym (N:Pos[0])) | |
| Complete | |
| (failK @ Value) | |
| `cast` | |
| (Sub (Sym (D:R:StateByteString[0])) | |
| ->_R <Pos | |
| -> More -> [String] -> String -> IResult ByteString Value>_R) | |
| (successK @ Value) | |
| `cast` | |
| (Sub (Sym (D:R:StateByteString[0])) | |
| ->_R <Pos | |
| -> More -> Value -> IResult ByteString Value>_R) of wild { | |
| Fail ds ds1 err -> case ds1 of wild1 { DEFAULT -> Nothing @ a } | |
| Partial ipv | |
| -> case error | |
| @ 'LiftedRep | |
| @ (Either String Value) | |
| (PushCallStack | |
| (build @ Char (\ @ b -> unpackFoldrCString# @ b "error"#)) | |
| (SrcLoc | |
| (build | |
| @ Char | |
| (\ @ b -> | |
| unpackFoldrCString# | |
| @ b | |
| "attoparsec-0.13.2.2-7134042ae4a8825e0220e72bbc50a3aea433895ec2d42a68a9d57176061e3182"#)) | |
| (build | |
| @ Char | |
| (\ @ b -> | |
| unpackFoldrCString# | |
| @ b | |
| "Data.Attoparsec.ByteString.Internal"#)) | |
| (build | |
| @ Char | |
| (\ @ b -> | |
| unpackFoldrCString# | |
| @ b | |
| "./Data/Attoparsec/ByteString/Internal.hs"#)) | |
| (I# 473#) | |
| (I# 38#) | |
| (I# 473#) | |
| (I# 74#)) | |
| EmptyCallStack) | |
| `cast` | |
| (Sym (N:IP[0] <"callStack">_N <CallStack>_N)) | |
| (build | |
| @ Char | |
| (\ @ b -> unpackFoldrCString# @ b "parseOnly: impossible error!"#)) | |
| ret_ty (Maybe a) | |
| of {} | |
| Done ds a1 | |
| -> case to a1 of wild1 { | |
| Error ipv -> Nothing @ a Success a2 -> Just @ a a2 } }) -} | |
| 8030bdd96260aa79f0c399d829528d73 | |
| decodeWith :: | |
| Parser Value -> (Value -> Result a) -> ByteString -> Maybe a | |
| {- Arity: 3, | |
| Strictness: <C(C(C(C(C(S))))),1*C1(C1(C1(C1(C1(U)))))><L,1*C1(U)><S,1*U>, | |
| Inline: (sat-args=3), | |
| Unfolding: InlineRule (3, False, False) | |
| (\ @ a | |
| (p :: Parser Value) | |
| (to :: Value -> Result a) | |
| (s :: ByteString) -> | |
| case parse @ Value p s of wild { | |
| Fail ipv ipv1 ipv2 -> Nothing @ a | |
| Done ds v2 | |
| -> case to v2 of wild1 { | |
| Error ipv -> Nothing @ a Success a1 -> Just @ a a1 } }) -} | |
| 363ec73531dc4166cd5de33bf179f895 | |
| eitherDecodeStrictWith :: | |
| Parser Value | |
| -> (Value -> IResult a) | |
| -> ByteString | |
| -> Either (JSONPath, String) a | |
| {- Arity: 3, | |
| Strictness: <C(C(C(C(C(S))))),1*C1(C1(C1(C1(C1(U)))))><L,1*C1(U)><L,1*U(U,U,U,U)>, | |
| Inline: (sat-args=3), | |
| Unfolding: InlineRule (3, False, False) | |
| (\ @ a | |
| (p :: Parser Value) | |
| (to :: Value -> IResult a) | |
| (s :: ByteString) -> | |
| case p `cast` (N:Parser[0] <ByteString>_N <Value>_R) | |
| @ Value | |
| (buffer s) `cast` (Sub (Sym (D:R:StateByteString[0]))) | |
| (I# 0#) `cast` (Sym (N:Pos[0])) | |
| Complete | |
| (failK @ Value) | |
| `cast` | |
| (Sub (Sym (D:R:StateByteString[0])) | |
| ->_R <Pos | |
| -> More -> [String] -> String -> IResult ByteString Value>_R) | |
| (successK @ Value) | |
| `cast` | |
| (Sub (Sym (D:R:StateByteString[0])) | |
| ->_R <Pos | |
| -> More -> Value -> IResult ByteString Value>_R) of wild { | |
| Fail ds ds1 err | |
| -> case ds1 of wild1 { | |
| [] -> Left @ (JSONPath, String) @ a ([] @ JSONPathElement, err) | |
| : ipv ipv1 | |
| -> Left | |
| @ (JSONPath, String) | |
| @ a | |
| ([] @ JSONPathElement, | |
| augment | |
| @ Char | |
| (\ @ b (c1 :: Char -> b -> b)[OneShot] (n1 :: b)[OneShot] -> | |
| foldr | |
| @ Char | |
| @ b | |
| c1 | |
| n1 | |
| (intercalate_$spoly_go | |
| @ Char | |
| ipv | |
| (prependToAll | |
| @ [Char] | |
| (build @ Char (\ @ b1 -> unpackFoldrCString# @ b1 " > "#)) | |
| ipv1))) | |
| (augment | |
| @ Char | |
| (\ @ b (c1 :: Char -> b -> b)[OneShot] (n1 :: b)[OneShot] -> | |
| unpackFoldrCString# @ b ": "# c1 n1) | |
| err)) } | |
| Partial ipv | |
| -> case error | |
| @ 'LiftedRep | |
| @ (Either String Value) | |
| (PushCallStack | |
| (build @ Char (\ @ b -> unpackFoldrCString# @ b "error"#)) | |
| (SrcLoc | |
| (build | |
| @ Char | |
| (\ @ b -> | |
| unpackFoldrCString# | |
| @ b | |
| "attoparsec-0.13.2.2-7134042ae4a8825e0220e72bbc50a3aea433895ec2d42a68a9d57176061e3182"#)) | |
| (build | |
| @ Char | |
| (\ @ b -> | |
| unpackFoldrCString# | |
| @ b | |
| "Data.Attoparsec.ByteString.Internal"#)) | |
| (build | |
| @ Char | |
| (\ @ b -> | |
| unpackFoldrCString# | |
| @ b | |
| "./Data/Attoparsec/ByteString/Internal.hs"#)) | |
| (I# 473#) | |
| (I# 38#) | |
| (I# 473#) | |
| (I# 74#)) | |
| EmptyCallStack) | |
| `cast` | |
| (Sym (N:IP[0] <"callStack">_N <CallStack>_N)) | |
| (build | |
| @ Char | |
| (\ @ b -> unpackFoldrCString# @ b "parseOnly: impossible error!"#)) | |
| ret_ty (Either (JSONPath, String) a) | |
| of {} | |
| Done ds a1 | |
| -> case to a1 of wild1 { | |
| IError path msg -> Left @ (JSONPath, String) @ a (path, msg) | |
| ISuccess a2 -> Right @ (JSONPath, String) @ a a2 } }) -} | |
| 951728cd0231dc6537dc1b08f38e60a3 | |
| eitherDecodeWith :: | |
| Parser Value | |
| -> (Value -> IResult a) | |
| -> ByteString | |
| -> Either (JSONPath, String) a | |
| {- Arity: 3, | |
| Strictness: <C(C(C(C(C(S))))),1*C1(C1(C1(C1(C1(U)))))><L,1*C1(U)><S,1*U>, | |
| Inline: (sat-args=3), | |
| Unfolding: InlineRule (3, False, False) | |
| (\ @ a | |
| (p :: Parser Value) | |
| (to :: Value -> IResult a) | |
| (s :: ByteString) -> | |
| case parse @ Value p s of wild { | |
| Fail ds ds1 msg | |
| -> Left | |
| @ ([JSONPathElement], String) | |
| @ a | |
| ([] @ JSONPathElement, msg) | |
| Done ds v2 | |
| -> case to v2 of wild1 { | |
| IError path msg -> Left @ (JSONPath, String) @ a (path, msg) | |
| ISuccess a1 -> Right @ (JSONPath, String) @ a a1 } }) -} | |
| a1152b3cc1316f3131190905b9e7ef3c | |
| json :: Parser Value | |
| {- Arity: 5, | |
| Strictness: <S(SLSSSS),1*U(U,U,U,U,U,U)><S(S),1*U(U)><L,U><L,C(C1(C1(C1(C1(U)))))><L,C(C1(C1(C1(U))))>, | |
| Unfolding: InlineRule (0, True, True) | |
| json1 `cast` (Sym (N:Parser[0] <ByteString>_N <Value>_R)) -} | |
| 75187e322199bb9e958a553b9ddc894b | |
| json' :: Parser Value | |
| {- Arity: 5, | |
| Strictness: <S(SLSSSS),1*U(U,U,U,U,U,U)><S(S),1*U(U)><L,U><L,C(C1(C1(C1(C1(U)))))><L,C(C1(C1(C1(U))))>, | |
| Unfolding: InlineRule (0, True, True) | |
| json'1 `cast` (Sym (N:Parser[0] <ByteString>_N <Value>_R)) -} | |
| 1002916f836931543773fcb9c77dc0aa | |
| json'1 :: | |
| State ByteString | |
| -> Pos | |
| -> More | |
| -> Failure ByteString (State ByteString) r | |
| -> Success ByteString (State ByteString) Value r | |
| -> IResult ByteString r | |
| {- Arity: 5, | |
| Strictness: <S(SLSSSS),1*U(U,U,U,U,U,U)><S(S),1*U(U)><L,U><L,C(C1(C1(C1(C1(U)))))><L,C(C1(C1(C1(U))))>, | |
| Inline: [0], | |
| Unfolding: InlineRule (5, True, False) | |
| (\ @ r | |
| (w :: State ByteString) | |
| (w1 :: Pos) | |
| (w2 :: More) | |
| (w3 :: Failure ByteString (State ByteString) r) | |
| (w4 :: Success ByteString (State ByteString) Value r) -> | |
| case w `cast` | |
| (Sub (D:R:StateByteString[0])) of ww { Buf ww1 ww2 ww3 ww4 ww5 ww6 -> | |
| case w1 `cast` (N:Pos[0]) of ww7 { I# ww8 -> | |
| $wvalue' @ r ww1 ww2 ww3 ww4 ww5 ww6 ww8 w2 w3 w4 } }) -} | |
| f7b2b1cb0c77d40250282429492ff14b | |
| json1 :: | |
| State ByteString | |
| -> Pos | |
| -> More | |
| -> Failure ByteString (State ByteString) r | |
| -> Success ByteString (State ByteString) Value r | |
| -> IResult ByteString r | |
| {- Arity: 5, | |
| Strictness: <S(SLSSSS),1*U(U,U,U,U,U,U)><S(S),1*U(U)><L,U><L,C(C1(C1(C1(C1(U)))))><L,C(C1(C1(C1(U))))>, | |
| Inline: [0], | |
| Unfolding: InlineRule (5, True, False) | |
| (\ @ r | |
| (w :: State ByteString) | |
| (w1 :: Pos) | |
| (w2 :: More) | |
| (w3 :: Failure ByteString (State ByteString) r) | |
| (w4 :: Success ByteString (State ByteString) Value r) -> | |
| case w `cast` | |
| (Sub (D:R:StateByteString[0])) of ww { Buf ww1 ww2 ww3 ww4 ww5 ww6 -> | |
| case w1 `cast` (N:Pos[0]) of ww7 { I# ww8 -> | |
| $wvalue @ r ww1 ww2 ww3 ww4 ww5 ww6 ww8 w2 w3 w4 } }) -} | |
| edd58b0c9831fccfcc40da46813a1544 | |
| jsonEOF :: Parser Value | |
| {- Arity: 5, | |
| Strictness: <S(SLSSSS),1*U(U,U,U,U,U,U)><S(S),1*U(U)><L,U><L,C(C1(C1(C1(C1(U)))))><L,C(C1(C1(C1(U))))>, | |
| Unfolding: InlineRule (0, True, True) | |
| jsonEOF1 `cast` (Sym (N:Parser[0] <ByteString>_N <Value>_R)) -} | |
| 3693d56076af8bff0b8b5f9c298c1da0 | |
| jsonEOF' :: Parser Value | |
| {- Arity: 5, | |
| Strictness: <S(SLSSSS),1*U(U,U,U,U,U,U)><S(S),1*U(U)><L,U><L,C(C1(C1(C1(C1(U)))))><L,C(C1(C1(C1(U))))>, | |
| Unfolding: InlineRule (0, True, True) | |
| jsonEOF'1 `cast` (Sym (N:Parser[0] <ByteString>_N <Value>_R)) -} | |
| 0c4ca2443def11483ad4d3784ea595d5 | |
| jsonEOF'1 :: | |
| State ByteString | |
| -> Pos | |
| -> More | |
| -> Failure ByteString (State ByteString) r | |
| -> Success ByteString (State ByteString) Value r | |
| -> IResult ByteString r | |
| {- Arity: 5, | |
| Strictness: <S(SLSSSS),1*U(U,U,U,U,U,U)><S(S),1*U(U)><L,U><L,C(C1(C1(C1(C1(U)))))><L,C(C1(C1(C1(U))))>, | |
| Inline: [0], | |
| Unfolding: InlineRule (5, True, False) | |
| (\ @ r | |
| (w :: State ByteString) | |
| (w1 :: Pos) | |
| (w2 :: More) | |
| (w3 :: Failure ByteString (State ByteString) r) | |
| (w4 :: Success ByteString (State ByteString) Value r) -> | |
| case w `cast` | |
| (Sub (D:R:StateByteString[0])) of ww { Buf ww1 ww2 ww3 ww4 ww5 ww6 -> | |
| case w1 `cast` (N:Pos[0]) of ww7 { I# ww8 -> | |
| $wjsonEOF' @ r ww1 ww2 ww3 ww4 ww5 ww6 ww8 w2 w3 w4 } }) -} | |
| 99a3f6c81f0c19d35d19c5355eb3c1a6 | |
| jsonEOF1 :: | |
| State ByteString | |
| -> Pos | |
| -> More | |
| -> Failure ByteString (State ByteString) r | |
| -> Success ByteString (State ByteString) Value r | |
| -> IResult ByteString r | |
| {- Arity: 5, | |
| Strictness: <S(SLSSSS),1*U(U,U,U,U,U,U)><S(S),1*U(U)><L,U><L,C(C1(C1(C1(C1(U)))))><L,C(C1(C1(C1(U))))>, | |
| Inline: [0], | |
| Unfolding: InlineRule (5, True, False) | |
| (\ @ r | |
| (w :: State ByteString) | |
| (w1 :: Pos) | |
| (w2 :: More) | |
| (w3 :: Failure ByteString (State ByteString) r) | |
| (w4 :: Success ByteString (State ByteString) Value r) -> | |
| case w `cast` | |
| (Sub (D:R:StateByteString[0])) of ww { Buf ww1 ww2 ww3 ww4 ww5 ww6 -> | |
| case w1 `cast` (N:Pos[0]) of ww7 { I# ww8 -> | |
| $wjsonEOF @ r ww1 ww2 ww3 ww4 ww5 ww6 ww8 w2 w3 w4 } }) -} | |
| f016caeb975b198f39082d36f845e325 | |
| jsonEOF_$s$wgo :: | |
| (State ByteString -> Pos -> More -> () -> IResult ByteString r) | |
| -> Int# | |
| -> Int# | |
| -> Int# | |
| -> Int# | |
| -> Int# | |
| -> ForeignPtrContents | |
| -> Addr# | |
| -> IResult ByteString r | |
| {- Arity: 8, | |
| Strictness: <L,C(C1(C1(C1(U))))><S,U><L,U><L,U><S,U><S,U><L,U><S,U> -} | |
| d17604a3730a9eb90f53edc59d439e50 | |
| jstring :: Parser Text | |
| {- Arity: 5, | |
| Strictness: <S(SLSSSS),1*U(U,U,U,U,U,U)><S(S),1*U(U)><L,U><L,C(C1(C1(C1(C1(U)))))><L,C(C1(C1(C1(U))))>, | |
| Unfolding: InlineRule (0, True, True) | |
| jstring1 `cast` (Sym (N:Parser[0] <ByteString>_N <Text>_R)) -} | |
| 1f8a020829c46481d38e2619344a45f9 | |
| jstring1 :: | |
| State ByteString | |
| -> Pos | |
| -> More | |
| -> Failure ByteString (State ByteString) r | |
| -> Success ByteString (State ByteString) Text r | |
| -> IResult ByteString r | |
| {- Arity: 5, | |
| Strictness: <S(SLSSSS),1*U(U,U,U,U,U,U)><S(S),1*U(U)><L,U><L,C(C1(C1(C1(C1(U)))))><L,C(C1(C1(C1(U))))>, | |
| Inline: [0], | |
| Unfolding: InlineRule (5, True, False) | |
| (\ @ r | |
| (w :: State ByteString) | |
| (w1 :: Pos) | |
| (w2 :: More) | |
| (w3 :: Failure ByteString (State ByteString) r) | |
| (w4 :: Success ByteString (State ByteString) Text r) -> | |
| case w `cast` | |
| (Sub (D:R:StateByteString[0])) of ww { Buf ww1 ww2 ww3 ww4 ww5 ww6 -> | |
| case w1 `cast` (N:Pos[0]) of ww7 { I# ww8 -> | |
| $wjstring @ r ww1 ww2 ww3 ww4 ww5 ww6 ww8 w2 w3 w4 } }) -} | |
| cc6eb41f4bae7b07d7b083e5425e2286 | |
| jstring_ :: Parser Text | |
| {- Arity: 5, | |
| Strictness: <S(SLSSSS),1*U(U,U,U,U,U,U)><S(S),1*U(U)><L,U><L,C(C1(C1(C1(C1(U)))))><L,C(C1(C1(C1(U))))>, | |
| Inline: (sat-args=0), | |
| Unfolding: InlineRule (0, False, False) | |
| (let { | |
| f :: S -> [ByteString] -> Parser (ByteString, S) {- Arity: 2 -} | |
| = \ (s2 :: S) (xs :: [ByteString]) -> | |
| let { | |
| $j :: Addr# | |
| -> ForeignPtrContents | |
| -> Int# | |
| -> Int# | |
| -> ByteString | |
| -> Parser ByteString (ByteString, S) | |
| <join 5> {- Arity: 5 -} | |
| = \ (ipv :: Addr#)[OneShot] | |
| (ipv1 :: ForeignPtrContents)[OneShot] | |
| (ipv2 :: Int#)[OneShot] | |
| (ipv3 :: Int#)[OneShot] | |
| (sx :: ByteString)[OneShot] -> | |
| let { | |
| v2 :: (ByteString, S) = (sx, s2) | |
| } in | |
| (\ @ r | |
| (t :: State ByteString) | |
| (pos :: Pos) | |
| (more :: More) | |
| (_lose :: Failure ByteString (State ByteString) r) | |
| (succ :: Success | |
| ByteString (State ByteString) (ByteString, S) r) -> | |
| case pos `cast` (N:Pos[0]) of nt { I# ipv4 -> | |
| succ t nt `cast` (Sym (N:Pos[0])) more v2 }) | |
| `cast` | |
| (Sym (N:Parser[0] <ByteString>_N <(ByteString, S)>_R)) | |
| } in | |
| case xs of wild { | |
| [] | |
| -> case mconcat | |
| @ ByteString | |
| $fMonoidByteString | |
| (reverse1 | |
| @ ByteString | |
| ([] @ ByteString) | |
| ([] @ ByteString)) of sx { PS ipv ipv1 ipv2 ipv3 -> | |
| $j ipv ipv1 ipv2 ipv3 sx } | |
| : x ds1 | |
| -> case ds1 of wild1 { | |
| [] | |
| -> case x of sx { PS ipv ipv1 ipv2 ipv3 -> | |
| $j ipv ipv1 ipv2 ipv3 sx } | |
| : ipv ipv1 | |
| -> case mconcat | |
| @ ByteString | |
| $fMonoidByteString | |
| (reverse1 | |
| @ ByteString | |
| wild | |
| ([] @ ByteString)) of sx { PS ipv2 ipv3 ipv4 ipv5 -> | |
| $j ipv2 ipv3 ipv4 ipv5 sx } } } | |
| } in | |
| letrec { | |
| go3 :: [ByteString] | |
| -> S | |
| -> forall r1. | |
| State ByteString | |
| -> Pos | |
| -> More | |
| -> Failure ByteString (State ByteString) r1 | |
| -> Success ByteString (State ByteString) (ByteString, S) r1 | |
| -> IResult ByteString r1 | |
| {- Arity: 7 -} | |
| = \ (acc :: [ByteString]) | |
| (s2 :: S) | |
| @ r1 | |
| (t :: State ByteString) | |
| (pos :: Pos) | |
| (more :: More) | |
| (lose :: Failure ByteString (State ByteString) r1) | |
| (succ :: Success | |
| ByteString (State ByteString) (ByteString, S) r1) -> | |
| case pos `cast` (N:Pos[0]) of nt { I# ipv -> | |
| let { | |
| bs :: ByteString | |
| = case t `cast` | |
| (Sub (D:R:StateByteString[0])) of wild { Buf dt dt1 dt2 dt3 dt4 dt5 -> | |
| $WPS | |
| (ForeignPtr @ Word8 dt dt1) | |
| (I# (+# dt2 ipv)) | |
| (I# (-# dt3 ipv)) } | |
| } in | |
| let { | |
| ds :: T S | |
| = case bs of wild { PS dt dt1 dt2 dt3 -> | |
| let { | |
| start :: Addr# = plusAddr# dt dt2 | |
| } in | |
| let { | |
| end :: Addr# = plusAddr# start dt3 | |
| } in | |
| letrec { | |
| inner :: Ptr Word8 -> S -> IO (T S) {- Arity: 2 -} | |
| = \ (ptr :: Ptr Word8) (s3 :: S) -> | |
| case s3 of s4 { S ipv1 ipv2 -> | |
| case ptr of wild1 { Ptr a2 -> | |
| case ltAddr# a2 end of lwild { | |
| DEFAULT | |
| -> (\ (s5 :: State# RealWorld) -> | |
| (# s5, $WT @ S (I# (minusAddr# a2 start)) s4 #)) | |
| `cast` | |
| (Sym (N:IO[0] <T S>_R)) | |
| 1# | |
| -> (\ (s5 :: State# RealWorld) -> | |
| case readWord8OffAddr# | |
| @ RealWorld | |
| a2 | |
| 0# | |
| s5 of ds2 { (#,#) ipv3 ipv4 -> | |
| let { | |
| w :: Int# = word2Int# ipv4 | |
| } in | |
| let { | |
| $j :: Int# -> (# State# RealWorld, T S #) | |
| <join 1> {- Arity: 1 -} | |
| = \ (skip' :: Int#)[OneShot] -> | |
| case ipv1 of lwild1 { | |
| DEFAULT | |
| -> case w of wild2 { | |
| DEFAULT | |
| -> (inner | |
| (Ptr @ Word8 (plusAddr# a2 1#)) | |
| (case andI# wild2 128# of wild3 { | |
| DEFAULT | |
| -> S skip' | |
| (orI# | |
| (orI# ipv2 skip') | |
| (==# (andI# wild2 31#) wild2)) | |
| 128# | |
| -> S skip' | |
| (orI# | |
| (orI# (orI# ipv2 1#) skip') | |
| (==# (andI# wild2 31#) wild2)) })) | |
| `cast` | |
| (N:IO[0] <T S>_R) | |
| ipv3 | |
| 34# | |
| -> (# ipv3, $WT @ S (I# (minusAddr# a2 start)) s4 #) } | |
| 1# | |
| -> (inner | |
| (Ptr @ Word8 (plusAddr# a2 1#)) | |
| (case andI# w 128# of wild2 { | |
| DEFAULT | |
| -> S 0# | |
| (orI# | |
| (orI# ipv2 skip') | |
| (==# (andI# w 31#) w)) | |
| 128# | |
| -> S 0# | |
| (orI# | |
| (orI# (orI# ipv2 1#) skip') | |
| (==# (andI# w 31#) w)) })) | |
| `cast` | |
| (N:IO[0] <T S>_R) | |
| ipv3 } | |
| } in | |
| case w of wild2 { DEFAULT -> $j 0# 92# -> $j 1# } }) | |
| `cast` | |
| (Sym (N:IO[0] <T S>_R)) } } } | |
| } in | |
| case (inner (Ptr @ Word8 start) s2) `cast` (N:IO[0] <T S>_R) | |
| realWorld# of ds1 { (#,#) ipv1 ipv2 -> | |
| case touch# | |
| @ 'LiftedRep | |
| @ ForeignPtrContents | |
| dt1 | |
| ipv1 of s' { DEFAULT -> | |
| ipv2 } } } | |
| } in | |
| let { | |
| i :: Int = case ds of wild { T dt s' -> I# dt } | |
| } in | |
| let { | |
| s' :: S = case ds of wild { T dt s'1 -> s'1 } | |
| } in | |
| case bs of wild { PS dt dt1 dt2 dt3 -> | |
| case $WPS | |
| (ForeignPtr @ Word8 dt dt1) | |
| (I# dt2) | |
| i of h { PS ipv1 ipv2 ipv3 ipv4 -> | |
| let { | |
| pos1 :: Int = case i of wild1 { I# y -> I# (+# ipv y) } | |
| } in | |
| case t `cast` | |
| (Sub (D:R:StateByteString[0])) of wild1 { Buf dt4 dt5 dt6 dt7 dt8 dt9 -> | |
| let { | |
| $j :: IResult ByteString r1 <join 0> | |
| = case pos1 of nt1 { I# ipv5 -> | |
| (f s' (: @ ByteString h acc)) | |
| `cast` | |
| (N:Parser[0] <ByteString>_N <(ByteString, S)>_R) | |
| @ r1 | |
| wild1 `cast` (Sub (Sym (D:R:StateByteString[0]))) | |
| nt1 `cast` (Sym (N:Pos[0])) | |
| more | |
| lose | |
| succ } | |
| } in | |
| case ltInt pos1 (I# dt7) of wild2 { | |
| False | |
| -> case more of wild3 { | |
| Complete -> $j | |
| Incomplete | |
| -> prompt_$sprompt1 | |
| @ r1 | |
| wild1 `cast` (Sub (Sym (D:R:StateByteString[0]))) | |
| pos1 `cast` (Sym (N:Pos[0])) | |
| Incomplete | |
| (\ (t' :: Buffer)[OneShot] | |
| (pos' :: Pos)[OneShot] | |
| (more' :: More)[OneShot] -> | |
| case pos' `cast` (N:Pos[0]) of nt1 { I# ipv5 -> | |
| (f s' (: @ ByteString h acc)) | |
| `cast` | |
| (N:Parser[0] <ByteString>_N <(ByteString, S)>_R) | |
| @ r1 | |
| t' `cast` (Sub (Sym (D:R:StateByteString[0]))) | |
| nt1 `cast` (Sym (N:Pos[0])) | |
| more' | |
| lose | |
| succ }) | |
| `cast` | |
| (Sub (Sym (D:R:StateByteString[0])) | |
| ->_R <Pos -> More -> IResult ByteString r1>_R) | |
| (\ (t' :: Buffer) | |
| (pos' :: Pos)[OneShot] | |
| (more' :: More)[OneShot] -> | |
| case pos' `cast` (N:Pos[0]) of nt1 { I# ipv5 -> | |
| go3 | |
| (: @ ByteString h acc) | |
| s' | |
| @ r1 | |
| t' `cast` (Sub (Sym (D:R:StateByteString[0]))) | |
| nt1 `cast` (Sym (N:Pos[0])) | |
| more' | |
| lose | |
| succ }) | |
| `cast` | |
| (Sub (Sym (D:R:StateByteString[0])) | |
| ->_R <Pos -> More -> IResult ByteString r1>_R) } | |
| True -> $j } } } } } | |
| } in | |
| let { | |
| x :: S = S 0# 0# | |
| } in | |
| (\ @ r | |
| (t :: State ByteString) | |
| (pos :: Pos) | |
| (more :: More) | |
| (lose :: Failure ByteString (State ByteString) r) | |
| (succ :: Success ByteString (State ByteString) Text r) -> | |
| case pos `cast` (N:Pos[0]) of nt { I# ipv -> | |
| let { | |
| succ1 :: Success ByteString (State ByteString) (ByteString, S) r | |
| {- Arity: 4 -} | |
| = \ (t' :: State ByteString) | |
| (pos' :: Pos) | |
| (more' :: More) | |
| (a1 :: (ByteString, S)) -> | |
| case pos' `cast` (N:Pos[0]) of nt1 { I# ipv1 -> | |
| case a1 of wild { (,) s ds -> | |
| case ds of wild1 { S ds1 escaped -> | |
| case escaped of lwild { | |
| DEFAULT -> succ t' nt1 `cast` (Sym (N:Pos[0])) more' (decodeUtf8 s) | |
| 1# | |
| -> case unescapeText s of wild2 { | |
| Left err | |
| -> lose | |
| t' | |
| nt1 `cast` (Sym (N:Pos[0])) | |
| more' | |
| ([] @ String) | |
| (augment | |
| @ Char | |
| (\ @ b (c1 :: Char -> b -> b)[OneShot] (n :: b)[OneShot] -> | |
| unpackFoldrCString# @ b "Failed reading: "# c1 n) | |
| ($fExceptionUnicodeException_$cshow err)) | |
| Right r1 -> succ t' nt1 `cast` (Sym (N:Pos[0])) more' r1 } } } } } | |
| } in | |
| go3 | |
| ([] @ ByteString) | |
| x | |
| @ r | |
| t | |
| nt `cast` (Sym (N:Pos[0])) | |
| more | |
| lose | |
| (\ (t' :: State ByteString) | |
| (pos' :: Pos) | |
| (more' :: More) | |
| (a1 :: (ByteString, S)) -> | |
| case pos' `cast` (N:Pos[0]) of nt1 { I# ipv1 -> | |
| case t' | |
| `cast` | |
| (Sub (D:R:StateByteString[0])) of wild { Buf dt dt1 dt2 dt3 dt4 dt5 -> | |
| case geInt (I# dt3) (I# (+# ipv1 1#)) of wild1 { | |
| False | |
| -> ensureSuspended | |
| @ r | |
| (I# 1#) | |
| wild | |
| nt1 `cast` (Sym (N:Pos[0])) | |
| more' | |
| lose | |
| `cast` | |
| (Sub (D:R:StateByteString[0]) | |
| ->_R <Pos -> More -> [String] -> String -> IResult ByteString r>_R) | |
| (\ (t'1 :: Buffer) | |
| (pos'1 :: Pos)[OneShot] | |
| (more'1 :: More)[OneShot] | |
| (bs' :: ByteString)[OneShot] -> | |
| case bs' of wild2 { PS dt7 dt8 dt9 dt10 -> | |
| case readWord8OffAddr# | |
| @ RealWorld | |
| (plusAddr# dt7 dt9) | |
| 0# | |
| realWorld# of ds2 { (#,#) ipv2 ipv3 -> | |
| case touch# | |
| @ 'LiftedRep | |
| @ ForeignPtrContents | |
| dt8 | |
| ipv2 of s' { DEFAULT -> | |
| case pos'1 `cast` (N:Pos[0]) of nt2 { I# ipv4 -> | |
| succ1 | |
| t'1 `cast` (Sub (Sym (D:R:StateByteString[0]))) | |
| (I# (+# ipv4 1#)) `cast` (Sym (N:Pos[0])) | |
| more'1 | |
| a1 } } } }) | |
| True | |
| -> succ1 | |
| wild `cast` (Sub (Sym (D:R:StateByteString[0]))) | |
| (I# (+# ipv1 1#)) `cast` (Sym (N:Pos[0])) | |
| more' | |
| a1 } } }) }) | |
| `cast` | |
| (Sym (N:Parser[0] <ByteString>_N <Text>_R))) -} | |
| 64a06b6ae248419ba3fe9df81236b6fe | |
| scientific :: Parser Scientific | |
| {- Arity: 5, | |
| Strictness: <S(SLSSSS),1*U(U,U,U,U,U,U)><S(S),1*U(U)><L,U><L,C(C1(C1(C1(C1(U)))))><L,C(C1(C1(C1(U))))>, | |
| Inline: (sat-args=0), | |
| Unfolding: InlineRule (0, False, False) | |
| (let { | |
| plus :: Word8 = W8# 43## | |
| } in | |
| let { | |
| minus :: Word8 = W8# 45## | |
| } in | |
| (\ @ r | |
| (t :: State ByteString) | |
| (pos :: Pos) | |
| (more :: More) | |
| (lose :: Failure ByteString (State ByteString) r) | |
| (succ :: Success ByteString (State ByteString) Scientific r) -> | |
| case pos `cast` (N:Pos[0]) of nt { I# ipv -> | |
| let { | |
| succ1 :: Success ByteString (State ByteString) Word8 r | |
| {- Arity: 4 -} | |
| = \ (t' :: State ByteString) | |
| (pos' :: Pos) | |
| (more' :: More) | |
| (a1 :: Word8) -> | |
| case pos' `cast` (N:Pos[0]) of nt1 { I# ipv1 -> | |
| let { | |
| $j :: Bool -> IResult ByteString r <join 1> {- Arity: 1 -} | |
| = \ (positive :: Bool)[OneShot] -> | |
| let { | |
| karg :: State ByteString | |
| -> Pos -> More -> () -> IResult ByteString r | |
| {- Arity: 4 -} | |
| = \ (t'1 :: State ByteString) | |
| (pos'1 :: Pos) | |
| (more'1 :: More) | |
| (a2 :: ()) -> | |
| case pos'1 `cast` (N:Pos[0]) of nt2 { I# ipv2 -> | |
| scientific1 | |
| @ r | |
| t'1 | |
| nt2 `cast` (Sym (N:Pos[0])) | |
| more'1 | |
| lose | |
| (\ (t'2 :: State ByteString) | |
| (pos'2 :: Pos)[OneShot] | |
| (more'2 :: More)[OneShot] | |
| (a3 :: Integer)[OneShot] -> | |
| case pos'2 `cast` (N:Pos[0]) of nt3 { I# ipv3 -> | |
| let { | |
| succ2 :: Success ByteString (State ByteString) (Maybe Word8) r | |
| {- Arity: 4 -} | |
| = \ (t'3 :: State ByteString) | |
| (pos'3 :: Pos) | |
| (more'3 :: More) | |
| (a4 :: Maybe Word8) -> | |
| case pos'3 `cast` (N:Pos[0]) of nt4 { I# ipv4 -> | |
| let { | |
| karg1 :: State ByteString | |
| -> Pos -> More -> SP -> IResult ByteString r | |
| {- Arity: 4 -} | |
| = \ (t'4 :: State ByteString) | |
| (pos'4 :: Pos) | |
| (more'4 :: More) | |
| (a5 :: SP) -> | |
| case pos'4 `cast` (N:Pos[0]) of nt5 { I# ipv5 -> | |
| case a5 of wild { SP c1 dt -> | |
| let { | |
| $j1 :: Integer -> IResult ByteString r | |
| <join 1> {- Arity: 1 -} | |
| = \ (signedCoeff :: Integer)[OneShot] -> | |
| let { | |
| bigE :: Word8 = W8# 69## | |
| } in | |
| let { | |
| littleE :: Word8 = W8# 101## | |
| } in | |
| let { | |
| v2 :: Scientific = $WScientific signedCoeff (I# dt) | |
| } in | |
| let { | |
| lose1 :: Failure ByteString (State ByteString) r | |
| {- Arity: 5 -} | |
| = \ (t'5 :: State ByteString) | |
| (_pos' :: Pos) | |
| (more'5 :: More) | |
| (_ctx :: [String]) | |
| (_msg :: String) -> | |
| succ t'5 nt5 `cast` (Sym (N:Pos[0])) more'5 v2 | |
| } in | |
| let { | |
| succ3 :: Success | |
| ByteString (State ByteString) Word8 r | |
| {- Arity: 4 -} | |
| = \ (t'5 :: State ByteString) | |
| (pos'5 :: Pos) | |
| (more'5 :: More) | |
| (a6 :: Word8) -> | |
| case pos'5 `cast` (N:Pos[0]) of nt6 { I# ipv6 -> | |
| let { | |
| $j2 :: IResult ByteString r <join 0> | |
| = signed_$ssigned6 | |
| decimal11 | |
| `cast` | |
| (Sym (N:Parser[0] <ByteString>_N <Int>_R)) | |
| @ r | |
| t'5 | |
| (I# (+# ipv6 1#)) `cast` (Sym (N:Pos[0])) | |
| more'5 | |
| lose1 | |
| (\ (t'6 :: State ByteString) | |
| (pos'6 :: Pos) | |
| (more'6 :: More) | |
| (a7 :: Int) -> | |
| succ | |
| t'6 | |
| pos'6 | |
| more'6 | |
| (case a7 of wild1 { I# y -> | |
| $WScientific | |
| signedCoeff | |
| (I# (+# dt y)) })) | |
| } in | |
| case eqWord8 a6 littleE of wild1 { | |
| False | |
| -> case eqWord8 a6 bigE of wild2 { | |
| False | |
| -> succ | |
| t'5 | |
| nt5 `cast` (Sym (N:Pos[0])) | |
| more'5 | |
| v2 | |
| True -> $j2 } | |
| True -> $j2 } } | |
| } in | |
| case t'4 | |
| `cast` | |
| (Sub (D:R:StateByteString[0])) of wild1 { Buf dt1 dt2 dt3 dt4 dt5 dt6 -> | |
| case geInt (I# dt4) (I# (+# ipv5 1#)) of wild2 { | |
| False | |
| -> ensureSuspended | |
| @ r | |
| (I# 1#) | |
| wild1 | |
| nt5 `cast` (Sym (N:Pos[0])) | |
| more'4 | |
| lose1 | |
| `cast` | |
| (Sub (D:R:StateByteString[0]) | |
| ->_R <Pos | |
| -> More | |
| -> [String] | |
| -> String | |
| -> IResult ByteString r>_R) | |
| (\ (t'5 :: Buffer) | |
| (pos'5 :: Pos)[OneShot] | |
| (more'5 :: More)[OneShot] | |
| (bs' :: ByteString)[OneShot] -> | |
| case bs' of wild3 { PS dt7 dt8 dt9 dt10 -> | |
| case readWord8OffAddr# | |
| @ RealWorld | |
| (plusAddr# dt7 dt9) | |
| 0# | |
| realWorld# of ds2 { (#,#) ipv6 ipv7 -> | |
| case touch# | |
| @ 'LiftedRep | |
| @ ForeignPtrContents | |
| dt8 | |
| ipv6 of s' { DEFAULT -> | |
| succ3 | |
| t'5 | |
| `cast` | |
| (Sub (Sym (D:R:StateByteString[0]))) | |
| pos'5 | |
| more'5 | |
| (W8# ipv7) } } }) | |
| True | |
| -> succ3 | |
| wild1 | |
| `cast` | |
| (Sub (Sym (D:R:StateByteString[0]))) | |
| nt5 `cast` (Sym (N:Pos[0])) | |
| more'4 | |
| (case readWord8OffAddr# | |
| @ RealWorld | |
| (plusAddr# dt1 (+# dt3 ipv5)) | |
| 0# | |
| realWorld# of ds2 { (#,#) ipv6 ipv7 -> | |
| case touch# | |
| @ 'LiftedRep | |
| @ ForeignPtrContents | |
| dt2 | |
| ipv6 of s' { DEFAULT -> | |
| W8# ipv7 } }) } } | |
| } in | |
| case positive of wild1 { | |
| False | |
| -> case negateInteger c1 of signedCoeff { DEFAULT -> | |
| $j1 signedCoeff } | |
| True -> $j1 c1 } } } | |
| } in | |
| let { | |
| fail :: Void# -> IResult ByteString r <join 1> {- Arity: 1 -} | |
| = \ (ds :: Void#)[OneShot] -> | |
| karg1 | |
| t'3 | |
| nt4 `cast` (Sym (N:Pos[0])) | |
| more'3 | |
| ($WSP a3 (I# 0#)) | |
| } in | |
| case a4 of wild { | |
| Nothing -> fail void# | |
| Just ds | |
| -> case eqWord8 ds (W8# 46##) of wild1 { | |
| False -> fail void# | |
| True | |
| -> let { | |
| k :: forall r1. | |
| State ByteString | |
| -> Pos | |
| -> More | |
| -> Failure ByteString (State ByteString) r1 | |
| -> Success ByteString (State ByteString) SP r1 | |
| -> IResult ByteString r1 | |
| {- Arity: 5 -} | |
| = \ @ r1 | |
| (t1 :: State ByteString) | |
| (pos1 :: Pos) | |
| (more1 :: More) | |
| (lose1 :: Failure | |
| ByteString (State ByteString) r1) | |
| (succ3 :: Success | |
| ByteString | |
| (State ByteString) | |
| SP | |
| r1) -> | |
| let { | |
| succ4 :: Success | |
| ByteString | |
| (State ByteString) | |
| ByteString | |
| r1 | |
| {- Arity: 4 -} | |
| = \ (t'4 :: State ByteString) | |
| (pos'4 :: Pos) | |
| (more'4 :: More) | |
| (a5 :: ByteString) -> | |
| succ3 | |
| t'4 | |
| pos'4 | |
| more'4 | |
| (case a5 of wild2 { PS dt dt1 dt2 dt3 -> | |
| letrec { | |
| go3 :: Integer | |
| -> Ptr Word8 | |
| -> Ptr Word8 | |
| -> IO Integer | |
| {- Arity: 3 -} | |
| = \ (z :: Integer) | |
| (p :: Ptr Word8) | |
| (q :: Ptr Word8) -> | |
| case z of z1 { DEFAULT -> | |
| case p of p1 { Ptr ipv5 -> | |
| case q of q1 { Ptr ipv6 -> | |
| case eqAddr# ipv5 ipv6 of lwild { | |
| DEFAULT | |
| -> (\ (s :: State# RealWorld) -> | |
| case readWord8OffAddr# | |
| @ RealWorld | |
| ipv5 | |
| 0# | |
| s of ds2 { (#,#) ipv7 ipv8 -> | |
| (go3 | |
| (plusInteger | |
| (timesInteger z1 10) | |
| (smallInteger | |
| (word2Int# | |
| (narrow8Word# | |
| (minusWord# | |
| ipv8 | |
| 48##))))) | |
| (Ptr | |
| @ Word8 | |
| (plusAddr# ipv5 1#)) | |
| q1) | |
| `cast` | |
| (N:IO[0] <Integer>_R) | |
| ipv7 }) | |
| `cast` | |
| (Sym (N:IO[0] <Integer>_R)) | |
| 1# | |
| -> (\ (s :: State# RealWorld) -> | |
| (# s, z1 #)) | |
| `cast` | |
| (Sym (N:IO[0] | |
| <Integer>_R)) } } } } | |
| } in | |
| case (go3 | |
| a3 | |
| (Ptr @ Word8 (plusAddr# dt dt2)) | |
| (Ptr | |
| @ Word8 | |
| (plusAddr# dt (+# dt2 dt3)))) | |
| `cast` | |
| (N:IO[0] <Integer>_R) | |
| realWorld# of ds1 { (#,#) ipv5 ipv6 -> | |
| case touch# | |
| @ 'LiftedRep | |
| @ ForeignPtrContents | |
| dt1 | |
| ipv5 of s' { DEFAULT -> | |
| $WSP ipv6 (I# (negateInt# dt3)) } } }) | |
| } in | |
| case pos1 `cast` (N:Pos[0]) of nt5 { I# ipv5 -> | |
| case t1 | |
| `cast` | |
| (Sub (D:R:StateByteString[0])) of wild2 { Buf dt dt1 dt2 dt3 dt4 dt5 -> | |
| let { | |
| karg2 :: State ByteString | |
| -> Pos | |
| -> More | |
| -> () | |
| -> IResult ByteString r1 | |
| {- Arity: 4 -} | |
| = \ (t'4 :: State ByteString) | |
| (pos'4 :: Pos) | |
| (more'4 :: More) | |
| (a5 :: ()) -> | |
| case pos'4 | |
| `cast` | |
| (N:Pos[0]) of nt6 { I# ipv6 -> | |
| let { | |
| a6 :: ByteString | |
| = case t'4 | |
| `cast` | |
| (Sub (D:R:StateByteString[0])) of wild3 { Buf dt7 dt8 dt9 dt10 dt11 dt12 -> | |
| case $WPS | |
| (ForeignPtr @ Word8 dt7 dt8) | |
| (I# (+# dt9 ipv6)) | |
| (I# | |
| (-# | |
| dt10 | |
| ipv6)) of wild4 { PS dt13 dt14 dt15 dt16 -> | |
| let { | |
| l :: Int = I# dt16 | |
| } in | |
| letrec { | |
| go3 :: Ptr Word8 -> Int -> IO Int | |
| {- Arity: 2 -} | |
| = \ (ptr :: Ptr Word8) (n1 :: Int) -> | |
| case ptr of ptr1 { Ptr ipv7 -> | |
| case n1 of n2 { I# ipv8 -> | |
| case geInt n2 l of wild5 { | |
| False | |
| -> (\ (s1 :: State# RealWorld) -> | |
| case readWord8OffAddr# | |
| @ RealWorld | |
| ipv7 | |
| 0# | |
| s1 of ds2 { (#,#) ipv9 ipv10 -> | |
| case leWord8 | |
| (W8# | |
| (narrow8Word# | |
| (minusWord# | |
| ipv10 | |
| 48##))) | |
| (W8# 9##) of wild6 { | |
| False -> (# ipv9, n2 #) | |
| True | |
| -> (go3 | |
| (Ptr | |
| @ Word8 | |
| (plusAddr# ipv7 1#)) | |
| (I# (+# ipv8 1#))) | |
| `cast` | |
| (N:IO[0] <Int>_R) | |
| ipv9 } }) | |
| `cast` | |
| (Sym (N:IO[0] <Int>_R)) | |
| True | |
| -> (\ (s1 :: State# RealWorld) -> | |
| (# s1, l #)) | |
| `cast` | |
| (Sym (N:IO[0] <Int>_R)) } } } | |
| } in | |
| case (go3 | |
| (Ptr | |
| @ Word8 | |
| (plusAddr# dt13 dt15)) | |
| (I# 0#)) | |
| `cast` | |
| (N:IO[0] <Int>_R) | |
| realWorld# of ds1 { (#,#) ipv7 ipv8 -> | |
| case touch# | |
| @ 'LiftedRep | |
| @ ForeignPtrContents | |
| dt14 | |
| ipv7 of s' { DEFAULT -> | |
| $WPS | |
| (ForeignPtr @ Word8 dt13 dt14) | |
| (I# dt15) | |
| ipv8 } } } } | |
| } in | |
| let { | |
| len :: Int | |
| = case a6 of wild3 { PS dt7 dt8 dt9 dt10 -> | |
| I# dt10 } | |
| } in | |
| case eqInt len (I# 0#) of wild3 { | |
| False | |
| -> case len of wild4 { I# y -> | |
| let { | |
| ipv7 :: Int# = +# ipv6 y | |
| } in | |
| let { | |
| nt7 :: Int = I# ipv7 | |
| } in | |
| case t'4 | |
| `cast` | |
| (Sub (D:R:StateByteString[0])) of wild5 { Buf dt7 dt8 dt9 dt10 dt11 dt12 -> | |
| case eqInt nt7 (I# dt10) of wild6 { | |
| False | |
| -> succ4 | |
| wild5 | |
| `cast` | |
| (Sub (Sym (D:R:StateByteString[0]))) | |
| nt7 `cast` (Sym (N:Pos[0])) | |
| more'4 | |
| a6 | |
| True | |
| -> letrec { | |
| go3 :: [ByteString] | |
| -> forall r2. | |
| State ByteString | |
| -> Pos | |
| -> More | |
| -> Failure | |
| ByteString | |
| (State ByteString) | |
| r2 | |
| -> Success | |
| ByteString | |
| (State ByteString) | |
| ByteString | |
| r2 | |
| -> IResult | |
| ByteString r2 | |
| {- Arity: 6 -} | |
| = \ (acc :: [ByteString]) | |
| @ r2 | |
| (t2 :: State ByteString) | |
| (pos2 :: Pos) | |
| (more2 :: More) | |
| (lose2 :: Failure | |
| ByteString | |
| (State | |
| ByteString) | |
| r2) | |
| (succ5 :: Success | |
| ByteString | |
| (State | |
| ByteString) | |
| ByteString | |
| r2) -> | |
| case pos2 | |
| `cast` | |
| (N:Pos[0]) of nt8 { I# ipv8 -> | |
| let { | |
| a7 :: ByteString | |
| = case t2 | |
| `cast` | |
| (Sub (D:R:StateByteString[0])) of wild7 { Buf dt13 dt14 dt15 dt16 dt17 dt18 -> | |
| case $WPS | |
| (ForeignPtr | |
| @ Word8 | |
| dt13 | |
| dt14) | |
| (I# (+# dt15 ipv8)) | |
| (I# | |
| (-# | |
| dt16 | |
| ipv8)) of wild8 { PS dt19 dt20 dt21 dt22 -> | |
| let { | |
| l :: Int = I# dt22 | |
| } in | |
| letrec { | |
| go4 :: Ptr Word8 | |
| -> Int -> IO Int | |
| {- Arity: 2 -} | |
| = \ (ptr :: Ptr Word8) | |
| (n1 :: Int) -> | |
| case ptr of ptr1 { Ptr ipv9 -> | |
| case n1 of n2 { I# ipv10 -> | |
| case geInt | |
| n2 | |
| l of wild9 { | |
| False | |
| -> (\ (s1 :: State# | |
| RealWorld) -> | |
| case readWord8OffAddr# | |
| @ RealWorld | |
| ipv9 | |
| 0# | |
| s1 of ds2 { (#,#) ipv11 ipv12 -> | |
| case leWord8 | |
| (W8# | |
| (narrow8Word# | |
| (minusWord# | |
| ipv12 | |
| 48##))) | |
| (W8# | |
| 9##) of wild10 { | |
| False | |
| -> (# ipv11, | |
| n2 #) | |
| True | |
| -> (go4 | |
| (Ptr | |
| @ Word8 | |
| (plusAddr# | |
| ipv9 | |
| 1#)) | |
| (I# | |
| (+# | |
| ipv10 | |
| 1#))) | |
| `cast` | |
| (N:IO[0] | |
| <Int>_R) | |
| ipv11 } }) | |
| `cast` | |
| (Sym (N:IO[0] | |
| <Int>_R)) | |
| True | |
| -> (\ (s1 :: State# | |
| RealWorld) -> | |
| (# s1, l #)) | |
| `cast` | |
| (Sym (N:IO[0] | |
| <Int>_R)) } } } | |
| } in | |
| case (go4 | |
| (Ptr | |
| @ Word8 | |
| (plusAddr# | |
| dt19 | |
| dt21)) | |
| (I# 0#)) | |
| `cast` | |
| (N:IO[0] <Int>_R) | |
| realWorld# of ds1 { (#,#) ipv9 ipv10 -> | |
| case touch# | |
| @ 'LiftedRep | |
| @ ForeignPtrContents | |
| dt20 | |
| ipv9 of s' { DEFAULT -> | |
| $WPS | |
| (ForeignPtr | |
| @ Word8 | |
| dt19 | |
| dt20) | |
| (I# dt21) | |
| ipv10 } } } } | |
| } in | |
| let { | |
| pos3 :: Int | |
| = case a7 of wild7 { PS dt13 dt14 dt15 dt16 -> | |
| I# (+# ipv8 dt16) } | |
| } in | |
| case t2 | |
| `cast` | |
| (Sub (D:R:StateByteString[0])) of wild7 { Buf dt13 dt14 dt15 dt16 dt17 dt18 -> | |
| let { | |
| $j1 :: IResult ByteString r2 | |
| <join 0> | |
| = case pos3 of nt9 { I# ipv9 -> | |
| succ5 | |
| wild7 | |
| `cast` | |
| (Sub (Sym (D:R:StateByteString[0]))) | |
| nt9 | |
| `cast` | |
| (Sym (N:Pos[0])) | |
| more2 | |
| (case acc of wild8 { | |
| [] -> a7 | |
| : ipv10 ipv11 | |
| -> mconcat | |
| @ ByteString | |
| $fMonoidByteString | |
| (reverse1 | |
| @ ByteString | |
| (: @ ByteString | |
| a7 | |
| wild8) | |
| ([] | |
| @ ByteString)) }) } | |
| } in | |
| case ltInt | |
| pos3 | |
| (I# dt16) of wild8 { | |
| False | |
| -> case more2 of wild9 { | |
| Complete -> $j1 | |
| Incomplete | |
| -> prompt_$sprompt1 | |
| @ r2 | |
| wild7 | |
| `cast` | |
| (Sub (Sym (D:R:StateByteString[0]))) | |
| pos3 | |
| `cast` | |
| (Sym (N:Pos[0])) | |
| Incomplete | |
| (\ (t'5 :: Buffer)[OneShot] | |
| (pos'5 :: Pos)[OneShot] | |
| (more'5 :: More)[OneShot] -> | |
| case pos'5 | |
| `cast` | |
| (N:Pos[0]) of nt9 { I# ipv9 -> | |
| succ5 | |
| t'5 | |
| `cast` | |
| (Sub (Sym (D:R:StateByteString[0]))) | |
| nt9 | |
| `cast` | |
| (Sym (N:Pos[0])) | |
| more'5 | |
| (case acc of wild10 { | |
| [] -> a7 | |
| : ipv10 ipv11 | |
| -> mconcat | |
| @ ByteString | |
| $fMonoidByteString | |
| (reverse1 | |
| @ ByteString | |
| (: @ ByteString | |
| a7 | |
| wild10) | |
| ([] | |
| @ ByteString)) }) }) | |
| `cast` | |
| (Sub (Sym (D:R:StateByteString[0])) | |
| ->_R <Pos | |
| -> More | |
| -> IResult | |
| ByteString | |
| r2>_R) | |
| (\ (t'5 :: Buffer) | |
| (pos'5 :: Pos)[OneShot] | |
| (more'5 :: More)[OneShot] -> | |
| case pos'5 | |
| `cast` | |
| (N:Pos[0]) of nt9 { I# ipv9 -> | |
| go3 | |
| (: @ ByteString | |
| a7 | |
| acc) | |
| @ r2 | |
| t'5 | |
| `cast` | |
| (Sub (Sym (D:R:StateByteString[0]))) | |
| nt9 | |
| `cast` | |
| (Sym (N:Pos[0])) | |
| more'5 | |
| lose2 | |
| succ5 }) | |
| `cast` | |
| (Sub (Sym (D:R:StateByteString[0])) | |
| ->_R <Pos | |
| -> More | |
| -> IResult | |
| ByteString | |
| r2>_R) } | |
| True -> $j1 } } } | |
| } in | |
| go3 | |
| (build | |
| @ ByteString | |
| (\ @ a | |
| (c1 :: ByteString | |
| -> a -> a)[OneShot] | |
| (n1 :: a)[OneShot] -> | |
| c1 a6 n1)) | |
| @ r1 | |
| wild5 | |
| `cast` | |
| (Sub (Sym (D:R:StateByteString[0]))) | |
| nt7 `cast` (Sym (N:Pos[0])) | |
| more'4 | |
| lose1 | |
| succ4 } } } | |
| True | |
| -> lose1 | |
| t'4 | |
| nt6 `cast` (Sym (N:Pos[0])) | |
| more'4 | |
| ([] @ String) | |
| (build | |
| @ Char | |
| (\ @ b | |
| (c1 :: Char -> b -> b)[OneShot] | |
| (n1 :: b)[OneShot] -> | |
| unpackFoldrCString# | |
| @ b | |
| "Failed reading: takeWhile1"# | |
| c1 | |
| n1)) } } | |
| } in | |
| case eqInt nt5 (I# dt3) of wild3 { | |
| False | |
| -> karg2 | |
| wild2 | |
| `cast` | |
| (Sub (Sym (D:R:StateByteString[0]))) | |
| nt5 `cast` (Sym (N:Pos[0])) | |
| more1 | |
| () | |
| True | |
| -> case more1 of wild4 { | |
| Complete | |
| -> lose1 | |
| wild2 | |
| `cast` | |
| (Sub (Sym (D:R:StateByteString[0]))) | |
| nt5 `cast` (Sym (N:Pos[0])) | |
| Complete | |
| ([] @ String) | |
| demandInput2 | |
| Incomplete | |
| -> let { | |
| lvl43 :: IResult ByteString r1 | |
| = lose1 | |
| wild2 | |
| `cast` | |
| (Sub (Sym (D:R:StateByteString[0]))) | |
| nt5 `cast` (Sym (N:Pos[0])) | |
| Complete | |
| ([] @ String) | |
| demandInput2 | |
| } in | |
| Partial | |
| @ ByteString | |
| @ r1 | |
| (\ (s1 :: ByteString) -> | |
| case s1 of wild5 { PS dt7 dt8 dt9 dt10 -> | |
| case leInt | |
| (I# dt10) | |
| (I# 0#) of wild6 { | |
| False | |
| -> karg2 | |
| (pappend wild2 wild5) | |
| `cast` | |
| (Sub (Sym (D:R:StateByteString[0]))) | |
| nt5 `cast` (Sym (N:Pos[0])) | |
| Incomplete | |
| () | |
| True -> lvl43 } }) } } } } | |
| } in | |
| case t'3 | |
| `cast` | |
| (Sub (D:R:StateByteString[0])) of wild2 { Buf dt dt1 dt2 dt3 dt4 dt5 -> | |
| case geInt (I# dt3) (I# (+# ipv4 1#)) of wild3 { | |
| False | |
| -> ensureSuspended | |
| @ r | |
| (I# 1#) | |
| wild2 | |
| nt4 `cast` (Sym (N:Pos[0])) | |
| more'3 | |
| lose | |
| `cast` | |
| (Sub (D:R:StateByteString[0]) | |
| ->_R <Pos | |
| -> More | |
| -> [String] | |
| -> String | |
| -> IResult ByteString r>_R) | |
| (\ (t'4 :: Buffer) | |
| (pos'4 :: Pos)[OneShot] | |
| (more'4 :: More)[OneShot] | |
| (bs' :: ByteString)[OneShot] -> | |
| case bs' of wild4 { PS dt7 dt8 dt9 dt10 -> | |
| case readWord8OffAddr# | |
| @ RealWorld | |
| (plusAddr# dt7 dt9) | |
| 0# | |
| realWorld# of ds2 { (#,#) ipv5 ipv6 -> | |
| case touch# | |
| @ 'LiftedRep | |
| @ ForeignPtrContents | |
| dt8 | |
| ipv5 of s' { DEFAULT -> | |
| case pos'4 | |
| `cast` | |
| (N:Pos[0]) of nt5 { I# ipv7 -> | |
| k @ r | |
| t'4 | |
| `cast` | |
| (Sub (Sym (D:R:StateByteString[0]))) | |
| (I# (+# ipv7 1#)) `cast` (Sym (N:Pos[0])) | |
| more'4 | |
| lose | |
| karg1 } } } }) | |
| True | |
| -> k @ r | |
| wild2 | |
| `cast` | |
| (Sub (Sym (D:R:StateByteString[0]))) | |
| (I# (+# ipv4 1#)) `cast` (Sym (N:Pos[0])) | |
| more'3 | |
| lose | |
| karg1 } } } } } | |
| } in | |
| case t'2 | |
| `cast` | |
| (Sub (D:R:StateByteString[0])) of wild { Buf dt dt1 dt2 dt3 dt4 dt5 -> | |
| case ltInt nt3 (I# dt3) of wild1 { | |
| False | |
| -> case more'2 of wild2 { | |
| Complete | |
| -> succ2 | |
| wild `cast` (Sub (Sym (D:R:StateByteString[0]))) | |
| nt3 `cast` (Sym (N:Pos[0])) | |
| Complete | |
| (Nothing @ Word8) | |
| Incomplete | |
| -> prompt_$sprompt1 | |
| @ r | |
| wild `cast` (Sub (Sym (D:R:StateByteString[0]))) | |
| nt3 `cast` (Sym (N:Pos[0])) | |
| Incomplete | |
| (\ (t'3 :: Buffer)[OneShot] | |
| (pos'3 :: Pos)[OneShot] | |
| (more'3 :: More)[OneShot] -> | |
| succ2 | |
| t'3 `cast` (Sub (Sym (D:R:StateByteString[0]))) | |
| pos'3 | |
| more'3 | |
| (Nothing @ Word8)) | |
| `cast` | |
| (Sub (Sym (D:R:StateByteString[0])) | |
| ->_R <Pos -> More -> IResult ByteString r>_R) | |
| (\ (t'3 :: Buffer) | |
| (pos'3 :: Pos)[OneShot] | |
| (more'3 :: More)[OneShot] -> | |
| case t'3 of wild3 { Buf dt7 dt8 dt9 dt10 dt11 dt12 -> | |
| case readWord8OffAddr# | |
| @ RealWorld | |
| (plusAddr# dt7 (+# dt9 ipv3)) | |
| 0# | |
| realWorld# of ds2 { (#,#) ipv4 ipv5 -> | |
| case touch# | |
| @ 'LiftedRep | |
| @ ForeignPtrContents | |
| dt8 | |
| ipv4 of s' { DEFAULT -> | |
| succ2 | |
| wild3 `cast` (Sub (Sym (D:R:StateByteString[0]))) | |
| pos'3 | |
| more'3 | |
| (Just @ Word8 (W8# ipv5)) } } }) | |
| `cast` | |
| (Sub (Sym (D:R:StateByteString[0])) | |
| ->_R <Pos -> More -> IResult ByteString r>_R) } | |
| True | |
| -> case readWord8OffAddr# | |
| @ RealWorld | |
| (plusAddr# dt (+# dt2 ipv3)) | |
| 0# | |
| realWorld# of ds2 { (#,#) ipv4 ipv5 -> | |
| case touch# | |
| @ 'LiftedRep | |
| @ ForeignPtrContents | |
| dt1 | |
| ipv4 of s' { DEFAULT -> | |
| succ2 | |
| wild `cast` (Sub (Sym (D:R:StateByteString[0]))) | |
| nt3 `cast` (Sym (N:Pos[0])) | |
| more'2 | |
| (Just @ Word8 (W8# ipv5)) } } } } }) } | |
| } in | |
| let { | |
| $j1 :: IResult ByteString r <join 0> | |
| = case t' | |
| `cast` | |
| (Sub (D:R:StateByteString[0])) of wild { Buf dt dt1 dt2 dt3 dt4 dt5 -> | |
| case geInt (I# dt3) (I# (+# ipv1 1#)) of wild1 { | |
| False | |
| -> ensureSuspended | |
| @ r | |
| (I# 1#) | |
| wild | |
| nt1 `cast` (Sym (N:Pos[0])) | |
| more' | |
| lose | |
| `cast` | |
| (Sub (D:R:StateByteString[0]) | |
| ->_R <Pos | |
| -> More | |
| -> [String] | |
| -> String | |
| -> IResult ByteString r>_R) | |
| (\ (t'1 :: Buffer) | |
| (pos'1 :: Pos)[OneShot] | |
| (more'1 :: More)[OneShot] | |
| (bs' :: ByteString)[OneShot] -> | |
| case bs' of wild2 { PS dt7 dt8 dt9 dt10 -> | |
| case readWord8OffAddr# | |
| @ RealWorld | |
| (plusAddr# dt7 dt9) | |
| 0# | |
| realWorld# of ds2 { (#,#) ipv2 ipv3 -> | |
| case touch# | |
| @ 'LiftedRep | |
| @ ForeignPtrContents | |
| dt8 | |
| ipv2 of s' { DEFAULT -> | |
| case pos'1 `cast` (N:Pos[0]) of nt2 { I# ipv4 -> | |
| karg | |
| t'1 `cast` (Sub (Sym (D:R:StateByteString[0]))) | |
| (I# (+# ipv4 1#)) `cast` (Sym (N:Pos[0])) | |
| more'1 | |
| () } } } }) | |
| True | |
| -> karg | |
| wild `cast` (Sub (Sym (D:R:StateByteString[0]))) | |
| (I# (+# ipv1 1#)) `cast` (Sym (N:Pos[0])) | |
| more' | |
| () } } | |
| } in | |
| case eqWord8 a1 plus of wild { | |
| False | |
| -> case eqWord8 a1 minus of wild1 { | |
| False -> karg t' nt1 `cast` (Sym (N:Pos[0])) more' () True -> $j1 } | |
| True -> $j1 } | |
| } in | |
| case eqWord8 a1 plus of wild { | |
| False | |
| -> case neWord8 a1 minus of positive { DEFAULT -> $j positive } | |
| True -> $j True } } | |
| } in | |
| case t `cast` | |
| (Sub (D:R:StateByteString[0])) of wild { Buf dt dt1 dt2 dt3 dt4 dt5 -> | |
| case geInt (I# dt3) (I# (+# ipv 1#)) of wild2 { | |
| False | |
| -> ensureSuspended | |
| @ r | |
| (I# 1#) | |
| wild | |
| nt `cast` (Sym (N:Pos[0])) | |
| more | |
| lose | |
| `cast` | |
| (Sub (D:R:StateByteString[0]) | |
| ->_R <Pos -> More -> [String] -> String -> IResult ByteString r>_R) | |
| (\ (t' :: Buffer) | |
| (pos' :: Pos)[OneShot] | |
| (more' :: More)[OneShot] | |
| (bs' :: ByteString)[OneShot] -> | |
| case bs' of wild3 { PS dt7 dt8 dt9 dt10 -> | |
| case readWord8OffAddr# | |
| @ RealWorld | |
| (plusAddr# dt7 dt9) | |
| 0# | |
| realWorld# of ds2 { (#,#) ipv1 ipv2 -> | |
| case touch# | |
| @ 'LiftedRep | |
| @ ForeignPtrContents | |
| dt8 | |
| ipv1 of s' { DEFAULT -> | |
| succ1 | |
| t' `cast` (Sub (Sym (D:R:StateByteString[0]))) | |
| pos' | |
| more' | |
| (W8# ipv2) } } }) | |
| True | |
| -> succ1 | |
| wild `cast` (Sub (Sym (D:R:StateByteString[0]))) | |
| nt `cast` (Sym (N:Pos[0])) | |
| more | |
| (case readWord8OffAddr# | |
| @ RealWorld | |
| (plusAddr# dt (+# dt2 ipv)) | |
| 0# | |
| realWorld# of ds2 { (#,#) ipv1 ipv2 -> | |
| case touch# | |
| @ 'LiftedRep | |
| @ ForeignPtrContents | |
| dt1 | |
| ipv1 of s' { DEFAULT -> | |
| W8# ipv2 } }) } } }) | |
| `cast` | |
| (Sym (N:Parser[0] <ByteString>_N <Scientific>_R))) -} | |
| 8f183e4abf6dd12302866ca5ecc47fdc | |
| scientific1 :: | |
| State ByteString | |
| -> Pos | |
| -> More | |
| -> Failure ByteString (State ByteString) r | |
| -> Success ByteString (State ByteString) Integer r | |
| -> IResult ByteString r | |
| {- Arity: 5, | |
| Strictness: <S(SLSSSS),1*U(U,U,U,U,U,U)><S(S),1*U(U)><L,U><L,C(C1(C1(C1(C1(U)))))><L,C(C1(C1(C1(U))))>, | |
| Inline: [0], | |
| Unfolding: InlineRule (5, True, False) | |
| (\ @ r | |
| (w :: State ByteString) | |
| (w1 :: Pos) | |
| (w2 :: More) | |
| (w3 :: Failure ByteString (State ByteString) r) | |
| (w4 :: Success ByteString (State ByteString) Integer r) -> | |
| case w `cast` | |
| (Sub (D:R:StateByteString[0])) of ww { Buf ww1 ww2 ww3 ww4 ww5 ww6 -> | |
| case w1 `cast` (N:Pos[0]) of ww7 { I# ww8 -> | |
| $wdecimal0 @ r ww1 ww2 ww3 ww4 ww5 ww6 ww8 w2 w3 w4 } }) -} | |
| f7418c232b0383aef0b95df8805c0e6d | |
| value :: Parser Value | |
| {- Arity: 5, | |
| Strictness: <S(SLSSSS),1*U(U,U,U,U,U,U)><S(S),1*U(U)><L,U><L,C(C1(C1(C1(C1(U)))))><L,C(C1(C1(C1(U))))>, | |
| Unfolding: InlineRule (0, True, True) | |
| json1 `cast` (Sym (N:Parser[0] <ByteString>_N <Value>_R)) -} | |
| 2b0e67a575e19096108ca4a928964bf3 | |
| value' :: Parser Value | |
| {- Arity: 5, | |
| Strictness: <S(SLSSSS),1*U(U,U,U,U,U,U)><S(S),1*U(U)><L,U><L,C(C1(C1(C1(C1(U)))))><L,C(C1(C1(C1(U))))>, | |
| Unfolding: InlineRule (0, True, True) | |
| json'1 `cast` (Sym (N:Parser[0] <ByteString>_N <Value>_R)) -} | |
| "SC:$wgo0" [0] forall @ r | |
| (sc :: State ByteString | |
| -> Pos -> More -> () -> IResult ByteString r) | |
| (sc1 :: Int#) | |
| (sc2 :: Int#) | |
| (sc3 :: Int#) | |
| (sc4 :: Int#) | |
| (sc5 :: Int#) | |
| (sc6 :: ForeignPtrContents) | |
| (sc7 :: Addr#) | |
| $wgo @ r sc7 sc6 sc5 sc4 sc3 sc2 sc1 Incomplete sc | |
| = jsonEOF_$s$wgo @ r sc sc1 sc2 sc3 sc4 sc5 sc6 sc7 | |
| "SC:$wpoly_go10" [0] forall @ v2 | |
| (sc :: State# RealWorld) | |
| (sc1 :: Word#) | |
| (sc2 :: SmallArray# (HashMap Text v2)) | |
| (sc3 :: Int#) | |
| (sc4 :: v2) | |
| (sc5 :: Int#) | |
| (sc6 :: Int#) | |
| (sc7 :: ByteArray#) | |
| (sc8 :: Word#) | |
| $wpoly_go1 @ v2 | |
| sc8 | |
| sc7 | |
| sc6 | |
| sc5 | |
| sc4 | |
| sc3 | |
| (BitmapIndexed @ Text @ v2 sc1 sc2) | |
| sc | |
| = $sunsafeInsert_$s$wpoly_go1 | |
| @ v2 | |
| sc | |
| sc1 | |
| sc2 | |
| sc3 | |
| sc4 | |
| sc5 | |
| sc6 | |
| sc7 | |
| sc8 | |
| vectorised variables: | |
| vectorised tycons: | |
| vectorised reused tycons: | |
| parallel variables: | |
| parallel tycons: | |
| trusted: none | |
| require own pkg trusted: False | |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment