{-# LANGUAGE Strict, MagicHash, AllowAmbiguousTypes, UnboxedTuples, CPP #-}
{-# OPTIONS_GHC -Wunused-imports #-}
{-# OPTIONS_GHC -Wno-redundant-bang-patterns #-}

module Agda.TypeChecking.Serialise.Node where

import GHC.Exts
import GHC.Word
import Agda.Utils.Serialize
import Agda.Utils.Word
import Data.Hashable
import Data.Bits

#include "MachDeps.h"

-- | Constructor tag (maybe omitted) and argument indices.
data Node
  = N0
  | N1# !Word32
  | N2# !Word64
  | N3# !Word64 !Word32
  | N4# !Word64 !Word64
  | N5# !Word64 !Word64 !Word32
  | N6# !Word64 !Word64 !Word64 !Node
  deriving (Int -> Node -> ShowS
[Node] -> ShowS
Node -> String
(Int -> Node -> ShowS)
-> (Node -> String) -> ([Node] -> ShowS) -> Show Node
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Node -> ShowS
showsPrec :: Int -> Node -> ShowS
$cshow :: Node -> String
show :: Node -> String
$cshowList :: [Node] -> ShowS
showList :: [Node] -> ShowS
Show)

pattern N1 :: Word32 -> Node
pattern $mN1 :: forall {r}. Node -> (Word32 -> r) -> ((# #) -> r) -> r
$bN1 :: Word32 -> Node
N1 a = N1# a
{-# INLINE N1 #-}

pattern N2 :: Word32 -> Word32 -> Node
pattern $mN2 :: forall {r}. Node -> (Word32 -> Word32 -> r) -> ((# #) -> r) -> r
$bN2 :: Word32 -> Word32 -> Node
N2 a b <- N2# (splitW64 -> (a, b)) where
  N2 Word32
a Word32
b = Word64 -> Node
N2# (Word32 -> Word32 -> Word64
packW64 Word32
a Word32
b)
{-# INLINE N2 #-}

pattern N3 :: Word32 -> Word32 -> Word32 -> Node
pattern $mN3 :: forall {r}.
Node -> (Word32 -> Word32 -> Word32 -> r) -> ((# #) -> r) -> r
$bN3 :: Word32 -> Word32 -> Word32 -> Node
N3 a b c <- N3# (splitW64 -> (a, b)) c where
  N3 Word32
a Word32
b Word32
c = Word64 -> Word32 -> Node
N3# (Word32 -> Word32 -> Word64
packW64 Word32
a Word32
b) Word32
c
{-# INLINE N3 #-}

pattern N4 :: Word32 -> Word32 -> Word32 -> Word32 -> Node
pattern $mN4 :: forall {r}.
Node
-> (Word32 -> Word32 -> Word32 -> Word32 -> r) -> ((# #) -> r) -> r
$bN4 :: Word32 -> Word32 -> Word32 -> Word32 -> Node
N4 a b c d <- N4# (splitW64 -> (a, b)) (splitW64 -> (c, d)) where
  N4 Word32
a Word32
b Word32
c Word32
d = Word64 -> Word64 -> Node
N4# (Word32 -> Word32 -> Word64
packW64 Word32
a Word32
b) (Word32 -> Word32 -> Word64
packW64 Word32
c Word32
d)
{-# INLINE N4 #-}

pattern N5 :: Word32 -> Word32 -> Word32 -> Word32 -> Word32 -> Node
pattern $mN5 :: forall {r}.
Node
-> (Word32 -> Word32 -> Word32 -> Word32 -> Word32 -> r)
-> ((# #) -> r)
-> r
$bN5 :: Word32 -> Word32 -> Word32 -> Word32 -> Word32 -> Node
N5 a b c d e <- N5# (splitW64 -> (a, b)) (splitW64 -> (c, d)) e where
  N5 Word32
a Word32
b Word32
c Word32
d Word32
e = Word64 -> Word64 -> Word32 -> Node
N5# (Word32 -> Word32 -> Word64
packW64 Word32
a Word32
b) (Word32 -> Word32 -> Word64
packW64 Word32
c Word32
d) Word32
e
{-# INLINE N5 #-}

pattern N6 :: Word32 -> Word32 -> Word32 -> Word32 -> Word32 -> Word32 -> Node -> Node
pattern $mN6 :: forall {r}.
Node
-> (Word32
    -> Word32 -> Word32 -> Word32 -> Word32 -> Word32 -> Node -> r)
-> ((# #) -> r)
-> r
$bN6 :: Word32
-> Word32 -> Word32 -> Word32 -> Word32 -> Word32 -> Node -> Node
N6 a b c d e f n <- N6# (splitW64 -> (a, b)) (splitW64 -> (c, d)) (splitW64 -> (e, f)) n where
  N6 Word32
a Word32
b Word32
c Word32
d Word32
e Word32
f Node
n = Word64 -> Word64 -> Word64 -> Node -> Node
N6# (Word32 -> Word32 -> Word64
packW64 Word32
a Word32
b) (Word32 -> Word32 -> Word64
packW64 Word32
c Word32
d) (Word32 -> Word32 -> Word64
packW64 Word32
e Word32
f) Node
n
{-# INLINE N6 #-}
{-# complete N0, N1, N2, N3, N4, N5, N6 #-}

instance Eq Node where
  Node
N0          == :: Node -> Node -> Bool
== Node
N0             = Bool
True
  N1# Word32
a       == N1# Word32
a'         = Word32
a Word32 -> Word32 -> Bool
forall a. Eq a => a -> a -> Bool
== Word32
a'
  N2# Word64
ab      == N2# Word64
ab'        = Word64
ab Word64 -> Word64 -> Bool
forall a. Eq a => a -> a -> Bool
== Word64
ab'
  N3# Word64
ab Word32
c    == N3# Word64
ab' Word32
c'     = Word64
ab Word64 -> Word64 -> Bool
forall a. Eq a => a -> a -> Bool
== Word64
ab' Bool -> Bool -> Bool
&& Word32
c Word32 -> Word32 -> Bool
forall a. Eq a => a -> a -> Bool
== Word32
c'
  N4# Word64
ab Word64
cd   == N4# Word64
ab' Word64
cd'    = Word64
ab Word64 -> Word64 -> Bool
forall a. Eq a => a -> a -> Bool
== Word64
ab' Bool -> Bool -> Bool
&& Word64
cd Word64 -> Word64 -> Bool
forall a. Eq a => a -> a -> Bool
== Word64
cd'
  N5# Word64
ab Word64
cd Word32
e == N5# Word64
ab' Word64
cd' Word32
e' = Word64
ab Word64 -> Word64 -> Bool
forall a. Eq a => a -> a -> Bool
== Word64
ab' Bool -> Bool -> Bool
&& Word64
cd Word64 -> Word64 -> Bool
forall a. Eq a => a -> a -> Bool
== Word64
cd' Bool -> Bool -> Bool
&& Word32
e Word32 -> Word32 -> Bool
forall a. Eq a => a -> a -> Bool
== Word32
e'
  N6# Word64
ab Word64
cd Word64
ef Node
n == N6# Word64
ab' Word64
cd' Word64
ef' Node
n' =
    Word64
ab Word64 -> Word64 -> Bool
forall a. Eq a => a -> a -> Bool
== Word64
ab' Bool -> Bool -> Bool
&& Word64
cd Word64 -> Word64 -> Bool
forall a. Eq a => a -> a -> Bool
== Word64
cd' Bool -> Bool -> Bool
&& Word64
ef Word64 -> Word64 -> Bool
forall a. Eq a => a -> a -> Bool
== Word64
ef' Bool -> Bool -> Bool
&& Node
n Node -> Node -> Bool
forall a. Eq a => a -> a -> Bool
== Node
n'
  Node
_ == Node
_ = Bool
False

instance Hashable Node where
  -- Adapted from https://github.com/tkaitchuck/aHash/wiki/AHash-fallback-algorithm
  hashWithSalt :: Int -> Node -> Int
hashWithSalt Int
h Node
n = Word -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Word -> Node -> Word
go (Int -> Word
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
h) Node
n) where
    xor :: Word -> Word -> Word
xor (W# Word#
x) (W# Word#
y) = Word# -> Word
W# (Word# -> Word# -> Word#
xor# Word#
x Word#
y)

    foldedMul :: Word -> Word -> Word
    foldedMul :: Word -> Word -> Word
foldedMul (W# Word#
x) (W# Word#
y) = case Word# -> Word# -> (# Word#, Word# #)
timesWord2# Word#
x Word#
y of (# Word#
hi, Word#
lo #) -> Word# -> Word
W# (Word# -> Word# -> Word#
xor# Word#
hi Word#
lo)

    combine :: Word -> Word -> Word
    combine :: Word -> Word -> Word
combine Word
x Word
y = Word -> Word -> Word
foldedMul (Word -> Word -> Word
xor Word
x Word
y) Word
factor where
      -- We use a version of fibonacci hashing, where our multiplier is the
      -- nearest prime to 2^64/phi or 2^32/phi. See https://stackoverflow.com/q/4113278.
#if WORD_SIZE_IN_BITS == 64
      factor :: Word
factor = Word
11400714819323198549
#else
      factor = 2654435741
#endif

    go :: Word -> Node -> Word
    go :: Word -> Node -> Word
go Word
h Node
N0           = Word
h
    go Word
h (N1# Word32
a)      = Word
h Word -> Word -> Word
`combine` Word32 -> Word
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word32
a
    go Word
h (N2# Word64
a)      = Word
h Word -> Word -> Word
`combine` Word64 -> Word
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word64
a
    go Word
h (N3# Word64
a Word32
b)    = Word
h Word -> Word -> Word
`combine` Word64 -> Word
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word64
a Word -> Word -> Word
`combine` Word32 -> Word
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word32
b
    go Word
h (N4# Word64
a Word64
b)    = Word
h Word -> Word -> Word
`combine` Word64 -> Word
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word64
a Word -> Word -> Word
`combine` Word64 -> Word
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word64
b
    go Word
h (N5# Word64
a Word64
b Word32
c)  = Word
h Word -> Word -> Word
`combine` Word64 -> Word
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word64
a Word -> Word -> Word
`combine` Word64 -> Word
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word64
b
                        Word -> Word -> Word
`combine` Word32 -> Word
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word32
c
    go Word
h (N6# Word64
a Word64
b Word64
c Node
n) = let h' :: Word
h' = Word
h Word -> Word -> Word
`combine` Word64 -> Word
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word64
a
                                   Word -> Word -> Word
`combine` Word64 -> Word
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word64
b Word -> Word -> Word
`combine` Word64 -> Word
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word64
c
                         in Word -> Node -> Word
go Word
h' Node
n

  hash :: Node -> Int
hash = Int -> Node -> Int
forall a. Hashable a => Int -> a -> Int
hashWithSalt Int
seed where
#if WORD_SIZE_IN_BITS == 64
      seed :: Int
seed = Int
3032525626373534813
#else
      seed = 1103515245
#endif

--------------------------------------------------------------------------------

instance Serialize Node where
  size :: Node -> Int
size = Int -> Node -> Int
go SIZEOF_HSINT where
    go :: Int -> Node -> Int
    go :: Int -> Node -> Int
go !Int
acc = \case
      Node
N0    -> Int
acc
      N1#{} -> Int
acc Int -> Int -> Int
forall a. Num a => a -> a -> a
+ SIZEOF_WORD32
      N2#{} -> Int
acc Int -> Int -> Int
forall a. Num a => a -> a -> a
+ SIZEOF_WORD64
      N3#{} -> Int
acc Int -> Int -> Int
forall a. Num a => a -> a -> a
+ SIZEOF_WORD64 + SIZEOF_WORD32
      N4#{} -> Int
acc Int -> Int -> Int
forall a. Num a => a -> a -> a
+ SIZEOF_WORD64 + SIZEOF_WORD64
      N5#{} -> Int
acc Int -> Int -> Int
forall a. Num a => a -> a -> a
+ SIZEOF_WORD64 + SIZEOF_WORD64 + SIZEOF_WORD32
      N6# Word64
_ Word64
_ Word64
_ Node
n -> Int -> Node -> Int
go (Int
acc Int -> Int -> Int
forall a. Num a => a -> a -> a
+ SIZEOF_WORD64 + SIZEOF_WORD64 + SIZEOF_WORD64) n

  put :: Node -> Put
put Node
n = (Addr# -> RW -> (# Addr#, RW #)) -> Put
Put \Addr#
hd RW
s -> let
    setHeader :: Int -> Addr# -> Put
    setHeader :: Int -> Addr# -> Put
setHeader Int
n Addr#
hd = (Addr# -> RW -> (# Addr#, RW #)) -> Put
Put \Addr#
p RW
s -> case Put -> Addr# -> RW -> (# Addr#, RW #)
unPut (Int -> Put
forall a. Serialize a => a -> Put
put Int
n) Addr#
hd RW
s of
      (# Addr#
_, RW
s #) -> (# Addr#
p, RW
s #)

    go :: Node -> Int -> Addr# -> Put
    go :: Node -> Int -> Addr# -> Put
go Node
n Int
l Addr#
hd = (Addr# -> RW -> (# Addr#, RW #)) -> Put
Put \Addr#
p RW
s -> case Node
n of
      Node
N0             -> Put -> Addr# -> RW -> (# Addr#, RW #)
unPut (Int -> Addr# -> Put
setHeader Int
l Addr#
hd) Addr#
p RW
s
      N1# Word32
a          -> Put -> Addr# -> RW -> (# Addr#, RW #)
unPut (Word32 -> Put
forall a. Serialize a => a -> Put
put Word32
a Put -> Put -> Put
forall a. Semigroup a => a -> a -> a
<> Int -> Addr# -> Put
setHeader (Int
l Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1) Addr#
hd) Addr#
p RW
s
      N2# Word64
ab         -> Put -> Addr# -> RW -> (# Addr#, RW #)
unPut (Word64 -> Put
forall a. Serialize a => a -> Put
put Word64
ab Put -> Put -> Put
forall a. Semigroup a => a -> a -> a
<> Int -> Addr# -> Put
setHeader (Int
l Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
2) Addr#
hd) Addr#
p RW
s
      N3# Word64
ab Word32
c       -> Put -> Addr# -> RW -> (# Addr#, RW #)
unPut (Word64 -> Put
forall a. Serialize a => a -> Put
put Word64
ab Put -> Put -> Put
forall a. Semigroup a => a -> a -> a
<> Word32 -> Put
forall a. Serialize a => a -> Put
put Word32
c Put -> Put -> Put
forall a. Semigroup a => a -> a -> a
<> Int -> Addr# -> Put
setHeader (Int
l Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
3) Addr#
hd) Addr#
p RW
s
      N4# Word64
ab Word64
cd      -> Put -> Addr# -> RW -> (# Addr#, RW #)
unPut (Word64 -> Put
forall a. Serialize a => a -> Put
put Word64
ab Put -> Put -> Put
forall a. Semigroup a => a -> a -> a
<> Word64 -> Put
forall a. Serialize a => a -> Put
put Word64
cd Put -> Put -> Put
forall a. Semigroup a => a -> a -> a
<> Int -> Addr# -> Put
setHeader (Int
l Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
4) Addr#
hd) Addr#
p RW
s
      N5# Word64
ab Word64
cd Word32
e    -> Put -> Addr# -> RW -> (# Addr#, RW #)
unPut (Word64 -> Put
forall a. Serialize a => a -> Put
put Word64
ab Put -> Put -> Put
forall a. Semigroup a => a -> a -> a
<> Word64 -> Put
forall a. Serialize a => a -> Put
put Word64
cd Put -> Put -> Put
forall a. Semigroup a => a -> a -> a
<> Word32 -> Put
forall a. Serialize a => a -> Put
put Word32
e Put -> Put -> Put
forall a. Semigroup a => a -> a -> a
<> Int -> Addr# -> Put
setHeader (Int
l Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
5) Addr#
hd) Addr#
p RW
s
      N6# Word64
ab Word64
cd Word64
ef Node
n -> Put -> Addr# -> RW -> (# Addr#, RW #)
unPut (Word64 -> Put
forall a. Serialize a => a -> Put
put Word64
ab Put -> Put -> Put
forall a. Semigroup a => a -> a -> a
<> Word64 -> Put
forall a. Serialize a => a -> Put
put Word64
cd Put -> Put -> Put
forall a. Semigroup a => a -> a -> a
<> Word64 -> Put
forall a. Serialize a => a -> Put
put Word64
ef Put -> Put -> Put
forall a. Semigroup a => a -> a -> a
<> Node -> Int -> Addr# -> Put
go Node
n (Int
l Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
6) Addr#
hd) Addr#
p RW
s

    in Put -> Addr# -> RW -> (# Addr#, RW #)
unPut (Node -> Int -> Addr# -> Put
go Node
n Int
0 Addr#
hd) (Addr# -> Int# -> Addr#
plusAddr# Addr#
hd SIZEOF_HSINT#) s

  get :: Get Node
get = do {l <- Get Int
forall a. Serialize a => Get a
get; ensure (unsafeShiftL l 2) \Addr#
_ -> Int -> Get Node
go Int
l} where
    g32 :: Get Word32; {-# INLINE g32 #-}
    g32 :: Get Word32
g32 = (Addr# -> Addr# -> RW -> (# Addr#, RW, Word32 #)) -> Get Word32
forall a. (Addr# -> Addr# -> RW -> (# Addr#, RW, a #)) -> Get a
Get \Addr#
_ Addr#
p RW
s -> case Addr# -> Int# -> RW -> (# RW, Word32# #)
forall d. Addr# -> Int# -> State# d -> (# State# d, Word32# #)
readWord32OffAddr# Addr#
p Int#
0# RW
s of
            (# RW
s, Word32#
x #) -> (# Addr# -> Int# -> Addr#
plusAddr# Addr#
p SIZEOF_WORD32#, s, W32# x #)
    g64 :: Get Word64; {-# INLINE g64 #-}
    g64 :: Get Word64
g64 = (Addr# -> Addr# -> RW -> (# Addr#, RW, Word64 #)) -> Get Word64
forall a. (Addr# -> Addr# -> RW -> (# Addr#, RW, a #)) -> Get a
Get \Addr#
_ Addr#
p RW
s -> case Addr# -> Int# -> RW -> (# RW, Word64# #)
forall d. Addr# -> Int# -> State# d -> (# State# d, Word64# #)
readWord64OffAddr# Addr#
p Int#
0# RW
s of
            (# RW
s, Word64#
x #) -> (# Addr# -> Int# -> Addr#
plusAddr# Addr#
p SIZEOF_WORD64#, s, W64# x #)

    go :: Int -> Get Node
    go :: Int -> Get Node
go Int
l = (Addr# -> Addr# -> RW -> (# Addr#, RW, Node #)) -> Get Node
forall a. (Addr# -> Addr# -> RW -> (# Addr#, RW, a #)) -> Get a
Get \Addr#
e Addr#
p RW
s -> case Int
l of
      Int
0 -> Get Node -> Addr# -> Addr# -> RW -> (# Addr#, RW, Node #)
forall a. Get a -> Addr# -> Addr# -> RW -> (# Addr#, RW, a #)
unGet (Node -> Get Node
forall a. a -> Get a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Node
N0) Addr#
e Addr#
p RW
s
      Int
1 -> Get Node -> Addr# -> Addr# -> RW -> (# Addr#, RW, Node #)
forall a. Get a -> Addr# -> Addr# -> RW -> (# Addr#, RW, a #)
unGet (Word32 -> Node
N1# (Word32 -> Node) -> Get Word32 -> Get Node
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Get Word32
g32) Addr#
e Addr#
p RW
s
      Int
2 -> Get Node -> Addr# -> Addr# -> RW -> (# Addr#, RW, Node #)
forall a. Get a -> Addr# -> Addr# -> RW -> (# Addr#, RW, a #)
unGet (Word64 -> Node
N2# (Word64 -> Node) -> Get Word64 -> Get Node
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Get Word64
g64) Addr#
e Addr#
p RW
s
      Int
3 -> Get Node -> Addr# -> Addr# -> RW -> (# Addr#, RW, Node #)
forall a. Get a -> Addr# -> Addr# -> RW -> (# Addr#, RW, a #)
unGet (Word64 -> Word32 -> Node
N3# (Word64 -> Word32 -> Node) -> Get Word64 -> Get (Word32 -> Node)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Get Word64
g64 Get (Word32 -> Node) -> Get Word32 -> Get Node
forall a b. Get (a -> b) -> Get a -> Get b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Get Word32
g32) Addr#
e Addr#
p RW
s
      Int
4 -> Get Node -> Addr# -> Addr# -> RW -> (# Addr#, RW, Node #)
forall a. Get a -> Addr# -> Addr# -> RW -> (# Addr#, RW, a #)
unGet (Word64 -> Word64 -> Node
N4# (Word64 -> Word64 -> Node) -> Get Word64 -> Get (Word64 -> Node)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Get Word64
g64 Get (Word64 -> Node) -> Get Word64 -> Get Node
forall a b. Get (a -> b) -> Get a -> Get b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Get Word64
g64) Addr#
e Addr#
p RW
s
      Int
5 -> Get Node -> Addr# -> Addr# -> RW -> (# Addr#, RW, Node #)
forall a. Get a -> Addr# -> Addr# -> RW -> (# Addr#, RW, a #)
unGet (Word64 -> Word64 -> Word32 -> Node
N5# (Word64 -> Word64 -> Word32 -> Node)
-> Get Word64 -> Get (Word64 -> Word32 -> Node)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Get Word64
g64 Get (Word64 -> Word32 -> Node)
-> Get Word64 -> Get (Word32 -> Node)
forall a b. Get (a -> b) -> Get a -> Get b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Get Word64
g64 Get (Word32 -> Node) -> Get Word32 -> Get Node
forall a b. Get (a -> b) -> Get a -> Get b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Get Word32
g32) Addr#
e Addr#
p RW
s
      Int
l -> Get Node -> Addr# -> Addr# -> RW -> (# Addr#, RW, Node #)
forall a. Get a -> Addr# -> Addr# -> RW -> (# Addr#, RW, a #)
unGet (Word64 -> Word64 -> Word64 -> Node -> Node
N6# (Word64 -> Word64 -> Word64 -> Node -> Node)
-> Get Word64 -> Get (Word64 -> Word64 -> Node -> Node)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Get Word64
g64 Get (Word64 -> Word64 -> Node -> Node)
-> Get Word64 -> Get (Word64 -> Node -> Node)
forall a b. Get (a -> b) -> Get a -> Get b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Get Word64
g64 Get (Word64 -> Node -> Node) -> Get Word64 -> Get (Node -> Node)
forall a b. Get (a -> b) -> Get a -> Get b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Get Word64
g64 Get (Node -> Node) -> Get Node -> Get Node
forall a b. Get (a -> b) -> Get a -> Get b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Int -> Get Node
go (Int
l Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
6)) Addr#
e Addr#
p RW
s