ghc-prim 0.3.1.0 → 0.4.0.0
raw patch · 12 files changed
+7225/−6316 lines, 12 filesPVP ok
version bump matches the API change (PVP)
API changes (from Hackage documentation)
- GHC.Prim: class Coercible a b
- GHC.Tuple: () :: ()
- GHC.Tuple: (,) :: a -> b -> (,) a b
- GHC.Tuple: (,,) :: a -> b -> c -> (,,) a b c
- GHC.Tuple: (,,,) :: a -> b -> c -> d -> (,,,) a b c d
- GHC.Tuple: (,,,,) :: a -> b -> c -> d -> e -> (,,,,) a b c d e
- GHC.Tuple: (,,,,,) :: a -> b -> c -> d -> e -> f -> (,,,,,) a b c d e f
- GHC.Tuple: (,,,,,,) :: a -> b -> c -> d -> e -> f -> g -> (,,,,,,) a b c d e f g
- GHC.Tuple: (,,,,,,,) :: a -> b -> c -> d -> e -> f -> g -> h -> (,,,,,,,) a b c d e f g h
- GHC.Tuple: (,,,,,,,,) :: a -> b -> c -> d -> e -> f -> g -> h -> i -> (,,,,,,,,) a b c d e f g h i
- GHC.Tuple: (,,,,,,,,,) :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> (,,,,,,,,,) a b c d e f g h i j
- GHC.Tuple: (,,,,,,,,,,) :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> (,,,,,,,,,,) a b c d e f g h i j k
- GHC.Tuple: (,,,,,,,,,,,) :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> (,,,,,,,,,,,) a b c d e f g h i j k l
- GHC.Tuple: (,,,,,,,,,,,,) :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> (,,,,,,,,,,,,) a b c d e f g h i j k l m
- GHC.Tuple: (,,,,,,,,,,,,,) :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> (,,,,,,,,,,,,,) a b c d e f g h i j k l m n
- GHC.Tuple: (,,,,,,,,,,,,,,) :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> (,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o
- GHC.Tuple: (,,,,,,,,,,,,,,,) :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> (,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p
- GHC.Tuple: (,,,,,,,,,,,,,,,,) :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> (,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q
- GHC.Tuple: (,,,,,,,,,,,,,,,,,) :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> r -> (,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r
- GHC.Tuple: (,,,,,,,,,,,,,,,,,,) :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> r -> s -> (,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s
- GHC.Tuple: (,,,,,,,,,,,,,,,,,,,) :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> r -> s -> t -> (,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t
- GHC.Tuple: (,,,,,,,,,,,,,,,,,,,,) :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> r -> s -> t -> u -> (,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u
- GHC.Tuple: (,,,,,,,,,,,,,,,,,,,,,) :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> r -> s -> t -> u -> v -> (,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v
- GHC.Tuple: (,,,,,,,,,,,,,,,,,,,,,,) :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> r -> s -> t -> u -> v -> w -> (,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w
- GHC.Tuple: (,,,,,,,,,,,,,,,,,,,,,,,) :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> r -> s -> t -> u -> v -> w -> x -> (,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x
- GHC.Tuple: (,,,,,,,,,,,,,,,,,,,,,,,,) :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> r -> s -> t -> u -> v -> w -> x -> y -> (,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y
- GHC.Tuple: (,,,,,,,,,,,,,,,,,,,,,,,,,) :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> r -> s -> t -> u -> v -> w -> x -> y -> z -> (,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z
- GHC.Tuple: (,,,,,,,,,,,,,,,,,,,,,,,,,,) :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> r -> s -> t -> u -> v -> w -> x -> y -> z -> a_ -> (,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_
- GHC.Tuple: (,,,,,,,,,,,,,,,,,,,,,,,,,,,) :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> r -> s -> t -> u -> v -> w -> x -> y -> z -> a_ -> b_ -> (,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_
- GHC.Tuple: (,,,,,,,,,,,,,,,,,,,,,,,,,,,,) :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> r -> s -> t -> u -> v -> w -> x -> y -> z -> a_ -> b_ -> c_ -> (,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_
- GHC.Tuple: (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> r -> s -> t -> u -> v -> w -> x -> y -> z -> a_ -> b_ -> c_ -> d_ -> (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_
- GHC.Tuple: (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> r -> s -> t -> u -> v -> w -> x -> y -> z -> a_ -> b_ -> c_ -> d_ -> e_ -> (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_
- GHC.Tuple: (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> r -> s -> t -> u -> v -> w -> x -> y -> z -> a_ -> b_ -> c_ -> d_ -> e_ -> f_ -> (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_
- GHC.Tuple: (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> r -> s -> t -> u -> v -> w -> x -> y -> z -> a_ -> b_ -> c_ -> d_ -> e_ -> f_ -> g_ -> (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_
- GHC.Tuple: (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> r -> s -> t -> u -> v -> w -> x -> y -> z -> a_ -> b_ -> c_ -> d_ -> e_ -> f_ -> g_ -> h_ -> (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_
- GHC.Tuple: (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> r -> s -> t -> u -> v -> w -> x -> y -> z -> a_ -> b_ -> c_ -> d_ -> e_ -> f_ -> g_ -> h_ -> i_ -> (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_
- GHC.Tuple: (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> r -> s -> t -> u -> v -> w -> x -> y -> z -> a_ -> b_ -> c_ -> d_ -> e_ -> f_ -> g_ -> h_ -> i_ -> j_ -> (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_
- GHC.Tuple: (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> r -> s -> t -> u -> v -> w -> x -> y -> z -> a_ -> b_ -> c_ -> d_ -> e_ -> f_ -> g_ -> h_ -> i_ -> j_ -> k_ -> (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_
- GHC.Tuple: (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> r -> s -> t -> u -> v -> w -> x -> y -> z -> a_ -> b_ -> c_ -> d_ -> e_ -> f_ -> g_ -> h_ -> i_ -> j_ -> k_ -> l_ -> (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_
- GHC.Tuple: (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> r -> s -> t -> u -> v -> w -> x -> y -> z -> a_ -> b_ -> c_ -> d_ -> e_ -> f_ -> g_ -> h_ -> i_ -> j_ -> k_ -> l_ -> m_ -> (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_
- GHC.Tuple: (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> r -> s -> t -> u -> v -> w -> x -> y -> z -> a_ -> b_ -> c_ -> d_ -> e_ -> f_ -> g_ -> h_ -> i_ -> j_ -> k_ -> l_ -> m_ -> n_ -> (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_
- GHC.Tuple: (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> r -> s -> t -> u -> v -> w -> x -> y -> z -> a_ -> b_ -> c_ -> d_ -> e_ -> f_ -> g_ -> h_ -> i_ -> j_ -> k_ -> l_ -> m_ -> n_ -> o_ -> (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_
- GHC.Tuple: (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> r -> s -> t -> u -> v -> w -> x -> y -> z -> a_ -> b_ -> c_ -> d_ -> e_ -> f_ -> g_ -> h_ -> i_ -> j_ -> k_ -> l_ -> m_ -> n_ -> o_ -> p_ -> (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_
- GHC.Tuple: (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> r -> s -> t -> u -> v -> w -> x -> y -> z -> a_ -> b_ -> c_ -> d_ -> e_ -> f_ -> g_ -> h_ -> i_ -> j_ -> k_ -> l_ -> m_ -> n_ -> o_ -> p_ -> q_ -> (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_
- GHC.Tuple: (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> r -> s -> t -> u -> v -> w -> x -> y -> z -> a_ -> b_ -> c_ -> d_ -> e_ -> f_ -> g_ -> h_ -> i_ -> j_ -> k_ -> l_ -> m_ -> n_ -> o_ -> p_ -> q_ -> r_ -> (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_
- GHC.Tuple: (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> r -> s -> t -> u -> v -> w -> x -> y -> z -> a_ -> b_ -> c_ -> d_ -> e_ -> f_ -> g_ -> h_ -> i_ -> j_ -> k_ -> l_ -> m_ -> n_ -> o_ -> p_ -> q_ -> r_ -> s_ -> (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_
- GHC.Tuple: (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> r -> s -> t -> u -> v -> w -> x -> y -> z -> a_ -> b_ -> c_ -> d_ -> e_ -> f_ -> g_ -> h_ -> i_ -> j_ -> k_ -> l_ -> m_ -> n_ -> o_ -> p_ -> q_ -> r_ -> s_ -> t_ -> (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_
- GHC.Tuple: (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> r -> s -> t -> u -> v -> w -> x -> y -> z -> a_ -> b_ -> c_ -> d_ -> e_ -> f_ -> g_ -> h_ -> i_ -> j_ -> k_ -> l_ -> m_ -> n_ -> o_ -> p_ -> q_ -> r_ -> s_ -> t_ -> u_ -> (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_
- GHC.Tuple: (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> r -> s -> t -> u -> v -> w -> x -> y -> z -> a_ -> b_ -> c_ -> d_ -> e_ -> f_ -> g_ -> h_ -> i_ -> j_ -> k_ -> l_ -> m_ -> n_ -> o_ -> p_ -> q_ -> r_ -> s_ -> t_ -> u_ -> v_ -> (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_
- GHC.Tuple: (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> r -> s -> t -> u -> v -> w -> x -> y -> z -> a_ -> b_ -> c_ -> d_ -> e_ -> f_ -> g_ -> h_ -> i_ -> j_ -> k_ -> l_ -> m_ -> n_ -> o_ -> p_ -> q_ -> r_ -> s_ -> t_ -> u_ -> v_ -> w_ -> (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_
- GHC.Tuple: (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> r -> s -> t -> u -> v -> w -> x -> y -> z -> a_ -> b_ -> c_ -> d_ -> e_ -> f_ -> g_ -> h_ -> i_ -> j_ -> k_ -> l_ -> m_ -> n_ -> o_ -> p_ -> q_ -> r_ -> s_ -> t_ -> u_ -> v_ -> w_ -> x_ -> (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_
- GHC.Tuple: (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> r -> s -> t -> u -> v -> w -> x -> y -> z -> a_ -> b_ -> c_ -> d_ -> e_ -> f_ -> g_ -> h_ -> i_ -> j_ -> k_ -> l_ -> m_ -> n_ -> o_ -> p_ -> q_ -> r_ -> s_ -> t_ -> u_ -> v_ -> w_ -> x_ -> y_ -> (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_
- GHC.Tuple: (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> r -> s -> t -> u -> v -> w -> x -> y -> z -> a_ -> b_ -> c_ -> d_ -> e_ -> f_ -> g_ -> h_ -> i_ -> j_ -> k_ -> l_ -> m_ -> n_ -> o_ -> p_ -> q_ -> r_ -> s_ -> t_ -> u_ -> v_ -> w_ -> x_ -> y_ -> z_ -> (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_
- GHC.Tuple: (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> r -> s -> t -> u -> v -> w -> x -> y -> z -> a_ -> b_ -> c_ -> d_ -> e_ -> f_ -> g_ -> h_ -> i_ -> j_ -> k_ -> l_ -> m_ -> n_ -> o_ -> p_ -> q_ -> r_ -> s_ -> t_ -> u_ -> v_ -> w_ -> x_ -> y_ -> z_ -> a__ -> (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__
- GHC.Tuple: (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> r -> s -> t -> u -> v -> w -> x -> y -> z -> a_ -> b_ -> c_ -> d_ -> e_ -> f_ -> g_ -> h_ -> i_ -> j_ -> k_ -> l_ -> m_ -> n_ -> o_ -> p_ -> q_ -> r_ -> s_ -> t_ -> u_ -> v_ -> w_ -> x_ -> y_ -> z_ -> a__ -> b__ -> (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__
- GHC.Tuple: (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> r -> s -> t -> u -> v -> w -> x -> y -> z -> a_ -> b_ -> c_ -> d_ -> e_ -> f_ -> g_ -> h_ -> i_ -> j_ -> k_ -> l_ -> m_ -> n_ -> o_ -> p_ -> q_ -> r_ -> s_ -> t_ -> u_ -> v_ -> w_ -> x_ -> y_ -> z_ -> a__ -> b__ -> c__ -> (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__
- GHC.Tuple: (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> r -> s -> t -> u -> v -> w -> x -> y -> z -> a_ -> b_ -> c_ -> d_ -> e_ -> f_ -> g_ -> h_ -> i_ -> j_ -> k_ -> l_ -> m_ -> n_ -> o_ -> p_ -> q_ -> r_ -> s_ -> t_ -> u_ -> v_ -> w_ -> x_ -> y_ -> z_ -> a__ -> b__ -> c__ -> d__ -> (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__
- GHC.Tuple: (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> r -> s -> t -> u -> v -> w -> x -> y -> z -> a_ -> b_ -> c_ -> d_ -> e_ -> f_ -> g_ -> h_ -> i_ -> j_ -> k_ -> l_ -> m_ -> n_ -> o_ -> p_ -> q_ -> r_ -> s_ -> t_ -> u_ -> v_ -> w_ -> x_ -> y_ -> z_ -> a__ -> b__ -> c__ -> d__ -> e__ -> (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__
- GHC.Tuple: (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> r -> s -> t -> u -> v -> w -> x -> y -> z -> a_ -> b_ -> c_ -> d_ -> e_ -> f_ -> g_ -> h_ -> i_ -> j_ -> k_ -> l_ -> m_ -> n_ -> o_ -> p_ -> q_ -> r_ -> s_ -> t_ -> u_ -> v_ -> w_ -> x_ -> y_ -> z_ -> a__ -> b__ -> c__ -> d__ -> e__ -> f__ -> (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__
- GHC.Tuple: (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> r -> s -> t -> u -> v -> w -> x -> y -> z -> a_ -> b_ -> c_ -> d_ -> e_ -> f_ -> g_ -> h_ -> i_ -> j_ -> k_ -> l_ -> m_ -> n_ -> o_ -> p_ -> q_ -> r_ -> s_ -> t_ -> u_ -> v_ -> w_ -> x_ -> y_ -> z_ -> a__ -> b__ -> c__ -> d__ -> e__ -> f__ -> g__ -> (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__
- GHC.Tuple: (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> r -> s -> t -> u -> v -> w -> x -> y -> z -> a_ -> b_ -> c_ -> d_ -> e_ -> f_ -> g_ -> h_ -> i_ -> j_ -> k_ -> l_ -> m_ -> n_ -> o_ -> p_ -> q_ -> r_ -> s_ -> t_ -> u_ -> v_ -> w_ -> x_ -> y_ -> z_ -> a__ -> b__ -> c__ -> d__ -> e__ -> f__ -> g__ -> h__ -> (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__
- GHC.Tuple: (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> r -> s -> t -> u -> v -> w -> x -> y -> z -> a_ -> b_ -> c_ -> d_ -> e_ -> f_ -> g_ -> h_ -> i_ -> j_ -> k_ -> l_ -> m_ -> n_ -> o_ -> p_ -> q_ -> r_ -> s_ -> t_ -> u_ -> v_ -> w_ -> x_ -> y_ -> z_ -> a__ -> b__ -> c__ -> d__ -> e__ -> f__ -> g__ -> h__ -> i__ -> (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__
- GHC.Tuple: (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> r -> s -> t -> u -> v -> w -> x -> y -> z -> a_ -> b_ -> c_ -> d_ -> e_ -> f_ -> g_ -> h_ -> i_ -> j_ -> k_ -> l_ -> m_ -> n_ -> o_ -> p_ -> q_ -> r_ -> s_ -> t_ -> u_ -> v_ -> w_ -> x_ -> y_ -> z_ -> a__ -> b__ -> c__ -> d__ -> e__ -> f__ -> g__ -> h__ -> i__ -> j__ -> (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__
- GHC.Types: C# :: Char# -> Char
- GHC.Types: D# :: Double# -> Double
- GHC.Types: EQ :: Ordering
- GHC.Types: F# :: Float# -> Float
- GHC.Types: False :: Bool
- GHC.Types: GT :: Ordering
- GHC.Types: I# :: Int# -> Int
- GHC.Types: IO :: (State# RealWorld -> (# State# RealWorld, a #)) -> IO a
- GHC.Types: LT :: Ordering
- GHC.Types: SPEC :: SPEC
- GHC.Types: SPEC2 :: SPEC
- GHC.Types: True :: Bool
- GHC.Types: W# :: Word# -> Word
+ GHC.Magic: oneShot :: (a -> b) -> (a -> b)
+ GHC.Prim: atomicReadIntArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, Int# #)
+ GHC.Prim: atomicWriteIntArray# :: MutableByteArray# s -> Int# -> Int# -> State# s -> State# s
+ GHC.Prim: casSmallArray# :: SmallMutableArray# s a -> Int# -> a -> a -> State# s -> (# State# s, Int#, a #)
+ GHC.Prim: cloneSmallArray# :: SmallArray# a -> Int# -> Int# -> SmallArray# a
+ GHC.Prim: cloneSmallMutableArray# :: SmallMutableArray# s a -> Int# -> Int# -> State# s -> (# State# s, SmallMutableArray# s a #)
+ GHC.Prim: clz# :: Word# -> Word#
+ GHC.Prim: clz16# :: Word# -> Word#
+ GHC.Prim: clz32# :: Word# -> Word#
+ GHC.Prim: clz64# :: Word# -> Word#
+ GHC.Prim: clz8# :: Word# -> Word#
+ GHC.Prim: copySmallArray# :: SmallArray# a -> Int# -> SmallMutableArray# s a -> Int# -> Int# -> State# s -> State# s
+ GHC.Prim: copySmallMutableArray# :: SmallMutableArray# s a -> Int# -> SmallMutableArray# s a -> Int# -> Int# -> State# s -> State# s
+ GHC.Prim: ctz# :: Word# -> Word#
+ GHC.Prim: ctz16# :: Word# -> Word#
+ GHC.Prim: ctz32# :: Word# -> Word#
+ GHC.Prim: ctz64# :: Word# -> Word#
+ GHC.Prim: ctz8# :: Word# -> Word#
+ GHC.Prim: data SmallArray# a
+ GHC.Prim: data SmallMutableArray# s a
+ GHC.Prim: decodeDouble_Int64# :: Double# -> (# Int#, Int# #)
+ GHC.Prim: fetchAndIntArray# :: MutableByteArray# s -> Int# -> Int# -> State# s -> (# State# s, Int# #)
+ GHC.Prim: fetchNandIntArray# :: MutableByteArray# s -> Int# -> Int# -> State# s -> (# State# s, Int# #)
+ GHC.Prim: fetchOrIntArray# :: MutableByteArray# s -> Int# -> Int# -> State# s -> (# State# s, Int# #)
+ GHC.Prim: fetchSubIntArray# :: MutableByteArray# s -> Int# -> Int# -> State# s -> (# State# s, Int# #)
+ GHC.Prim: fetchXorIntArray# :: MutableByteArray# s -> Int# -> Int# -> State# s -> (# State# s, Int# #)
+ GHC.Prim: freezeSmallArray# :: SmallMutableArray# s a -> Int# -> Int# -> State# s -> (# State# s, SmallArray# a #)
+ GHC.Prim: indexSmallArray# :: SmallArray# a -> Int# -> (# a #)
+ GHC.Prim: newSmallArray# :: Int# -> a -> State# s -> (# State# s, SmallMutableArray# s a #)
+ GHC.Prim: prefetchValue0# :: a -> State# s -> State# s
+ GHC.Prim: prefetchValue1# :: a -> State# s -> State# s
+ GHC.Prim: prefetchValue2# :: a -> State# s -> State# s
+ GHC.Prim: prefetchValue3# :: a -> State# s -> State# s
+ GHC.Prim: readSmallArray# :: SmallMutableArray# s a -> Int# -> State# s -> (# State# s, a #)
+ GHC.Prim: resizeMutableByteArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, MutableByteArray# s #)
+ GHC.Prim: sameSmallMutableArray# :: SmallMutableArray# s a -> SmallMutableArray# s a -> Int#
+ GHC.Prim: shrinkMutableByteArray# :: MutableByteArray# s -> Int# -> State# s -> State# s
+ GHC.Prim: sizeofSmallArray# :: SmallArray# a -> Int#
+ GHC.Prim: sizeofSmallMutableArray# :: SmallMutableArray# s a -> Int#
+ GHC.Prim: thawSmallArray# :: SmallArray# a -> Int# -> Int# -> State# s -> (# State# s, SmallMutableArray# s a #)
+ GHC.Prim: unsafeFreezeSmallArray# :: SmallMutableArray# s a -> State# s -> (# State# s, SmallArray# a #)
+ GHC.Prim: unsafeThawSmallArray# :: SmallArray# a -> State# s -> (# State# s, SmallMutableArray# s a #)
+ GHC.Prim: writeSmallArray# :: SmallMutableArray# s a -> Int# -> a -> State# s -> State# s
+ GHC.PrimopWrappers: atomicReadIntArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, Int# #)
+ GHC.PrimopWrappers: atomicWriteIntArray# :: MutableByteArray# s -> Int# -> Int# -> State# s -> State# s
+ GHC.PrimopWrappers: casSmallArray# :: SmallMutableArray# s a -> Int# -> a -> a -> State# s -> (# State# s, Int#, a #)
+ GHC.PrimopWrappers: cloneSmallArray# :: SmallArray# a -> Int# -> Int# -> SmallArray# a
+ GHC.PrimopWrappers: cloneSmallMutableArray# :: SmallMutableArray# s a -> Int# -> Int# -> State# s -> (# State# s, SmallMutableArray# s a #)
+ GHC.PrimopWrappers: clz# :: Word# -> Word#
+ GHC.PrimopWrappers: clz16# :: Word# -> Word#
+ GHC.PrimopWrappers: clz32# :: Word# -> Word#
+ GHC.PrimopWrappers: clz64# :: Word# -> Word#
+ GHC.PrimopWrappers: clz8# :: Word# -> Word#
+ GHC.PrimopWrappers: copySmallArray# :: SmallArray# a -> Int# -> SmallMutableArray# s a -> Int# -> Int# -> State# s -> State# s
+ GHC.PrimopWrappers: copySmallMutableArray# :: SmallMutableArray# s a -> Int# -> SmallMutableArray# s a -> Int# -> Int# -> State# s -> State# s
+ GHC.PrimopWrappers: ctz# :: Word# -> Word#
+ GHC.PrimopWrappers: ctz16# :: Word# -> Word#
+ GHC.PrimopWrappers: ctz32# :: Word# -> Word#
+ GHC.PrimopWrappers: ctz64# :: Word# -> Word#
+ GHC.PrimopWrappers: ctz8# :: Word# -> Word#
+ GHC.PrimopWrappers: decodeDouble_Int64# :: Double# -> (# Int#, Int# #)
+ GHC.PrimopWrappers: fetchAndIntArray# :: MutableByteArray# s -> Int# -> Int# -> State# s -> (# State# s, Int# #)
+ GHC.PrimopWrappers: fetchNandIntArray# :: MutableByteArray# s -> Int# -> Int# -> State# s -> (# State# s, Int# #)
+ GHC.PrimopWrappers: fetchOrIntArray# :: MutableByteArray# s -> Int# -> Int# -> State# s -> (# State# s, Int# #)
+ GHC.PrimopWrappers: fetchSubIntArray# :: MutableByteArray# s -> Int# -> Int# -> State# s -> (# State# s, Int# #)
+ GHC.PrimopWrappers: fetchXorIntArray# :: MutableByteArray# s -> Int# -> Int# -> State# s -> (# State# s, Int# #)
+ GHC.PrimopWrappers: freezeSmallArray# :: SmallMutableArray# s a -> Int# -> Int# -> State# s -> (# State# s, SmallArray# a #)
+ GHC.PrimopWrappers: indexSmallArray# :: SmallArray# a -> Int# -> (# a #)
+ GHC.PrimopWrappers: newSmallArray# :: Int# -> a -> State# s -> (# State# s, SmallMutableArray# s a #)
+ GHC.PrimopWrappers: prefetchValue0# :: a -> State# s -> State# s
+ GHC.PrimopWrappers: prefetchValue1# :: a -> State# s -> State# s
+ GHC.PrimopWrappers: prefetchValue2# :: a -> State# s -> State# s
+ GHC.PrimopWrappers: prefetchValue3# :: a -> State# s -> State# s
+ GHC.PrimopWrappers: readSmallArray# :: SmallMutableArray# s a -> Int# -> State# s -> (# State# s, a #)
+ GHC.PrimopWrappers: resizeMutableByteArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, MutableByteArray# s #)
+ GHC.PrimopWrappers: sameSmallMutableArray# :: SmallMutableArray# s a -> SmallMutableArray# s a -> Int#
+ GHC.PrimopWrappers: shrinkMutableByteArray# :: MutableByteArray# s -> Int# -> State# s -> State# s
+ GHC.PrimopWrappers: sizeofSmallArray# :: SmallArray# a -> Int#
+ GHC.PrimopWrappers: sizeofSmallMutableArray# :: SmallMutableArray# s a -> Int#
+ GHC.PrimopWrappers: thawSmallArray# :: SmallArray# a -> Int# -> Int# -> State# s -> (# State# s, SmallMutableArray# s a #)
+ GHC.PrimopWrappers: unsafeFreezeSmallArray# :: SmallMutableArray# s a -> State# s -> (# State# s, SmallArray# a #)
+ GHC.PrimopWrappers: unsafeThawSmallArray# :: SmallArray# a -> State# s -> (# State# s, SmallMutableArray# s a #)
+ GHC.PrimopWrappers: writeSmallArray# :: SmallMutableArray# s a -> Int# -> a -> State# s -> State# s
+ GHC.Tuple: [()] :: ()
+ GHC.Tuple: [(,)] :: a -> b -> (,) a b
+ GHC.Tuple: [(,,)] :: a -> b -> c -> (,,) a b c
+ GHC.Tuple: [(,,,)] :: a -> b -> c -> d -> (,,,) a b c d
+ GHC.Tuple: [(,,,,)] :: a -> b -> c -> d -> e -> (,,,,) a b c d e
+ GHC.Tuple: [(,,,,,)] :: a -> b -> c -> d -> e -> f -> (,,,,,) a b c d e f
+ GHC.Tuple: [(,,,,,,)] :: a -> b -> c -> d -> e -> f -> g -> (,,,,,,) a b c d e f g
+ GHC.Tuple: [(,,,,,,,)] :: a -> b -> c -> d -> e -> f -> g -> h -> (,,,,,,,) a b c d e f g h
+ GHC.Tuple: [(,,,,,,,,)] :: a -> b -> c -> d -> e -> f -> g -> h -> i -> (,,,,,,,,) a b c d e f g h i
+ GHC.Tuple: [(,,,,,,,,,)] :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> (,,,,,,,,,) a b c d e f g h i j
+ GHC.Tuple: [(,,,,,,,,,,)] :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> (,,,,,,,,,,) a b c d e f g h i j k
+ GHC.Tuple: [(,,,,,,,,,,,)] :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> (,,,,,,,,,,,) a b c d e f g h i j k l
+ GHC.Tuple: [(,,,,,,,,,,,,)] :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> (,,,,,,,,,,,,) a b c d e f g h i j k l m
+ GHC.Tuple: [(,,,,,,,,,,,,,)] :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> (,,,,,,,,,,,,,) a b c d e f g h i j k l m n
+ GHC.Tuple: [(,,,,,,,,,,,,,,)] :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> (,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o
+ GHC.Tuple: [(,,,,,,,,,,,,,,,)] :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> (,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p
+ GHC.Tuple: [(,,,,,,,,,,,,,,,,)] :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> (,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q
+ GHC.Tuple: [(,,,,,,,,,,,,,,,,,)] :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> r -> (,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r
+ GHC.Tuple: [(,,,,,,,,,,,,,,,,,,)] :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> r -> s -> (,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s
+ GHC.Tuple: [(,,,,,,,,,,,,,,,,,,,)] :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> r -> s -> t -> (,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t
+ GHC.Tuple: [(,,,,,,,,,,,,,,,,,,,,)] :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> r -> s -> t -> u -> (,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u
+ GHC.Tuple: [(,,,,,,,,,,,,,,,,,,,,,)] :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> r -> s -> t -> u -> v -> (,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v
+ GHC.Tuple: [(,,,,,,,,,,,,,,,,,,,,,,)] :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> r -> s -> t -> u -> v -> w -> (,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w
+ GHC.Tuple: [(,,,,,,,,,,,,,,,,,,,,,,,)] :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> r -> s -> t -> u -> v -> w -> x -> (,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x
+ GHC.Tuple: [(,,,,,,,,,,,,,,,,,,,,,,,,)] :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> r -> s -> t -> u -> v -> w -> x -> y -> (,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y
+ GHC.Tuple: [(,,,,,,,,,,,,,,,,,,,,,,,,,)] :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> r -> s -> t -> u -> v -> w -> x -> y -> z -> (,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z
+ GHC.Tuple: [(,,,,,,,,,,,,,,,,,,,,,,,,,,)] :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> r -> s -> t -> u -> v -> w -> x -> y -> z -> a_ -> (,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_
+ GHC.Tuple: [(,,,,,,,,,,,,,,,,,,,,,,,,,,,)] :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> r -> s -> t -> u -> v -> w -> x -> y -> z -> a_ -> b_ -> (,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_
+ GHC.Tuple: [(,,,,,,,,,,,,,,,,,,,,,,,,,,,,)] :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> r -> s -> t -> u -> v -> w -> x -> y -> z -> a_ -> b_ -> c_ -> (,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_
+ GHC.Tuple: [(,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)] :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> r -> s -> t -> u -> v -> w -> x -> y -> z -> a_ -> b_ -> c_ -> d_ -> (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_
+ GHC.Tuple: [(,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)] :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> r -> s -> t -> u -> v -> w -> x -> y -> z -> a_ -> b_ -> c_ -> d_ -> e_ -> (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_
+ GHC.Tuple: [(,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)] :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> r -> s -> t -> u -> v -> w -> x -> y -> z -> a_ -> b_ -> c_ -> d_ -> e_ -> f_ -> (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_
+ GHC.Tuple: [(,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)] :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> r -> s -> t -> u -> v -> w -> x -> y -> z -> a_ -> b_ -> c_ -> d_ -> e_ -> f_ -> g_ -> (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_
+ GHC.Tuple: [(,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)] :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> r -> s -> t -> u -> v -> w -> x -> y -> z -> a_ -> b_ -> c_ -> d_ -> e_ -> f_ -> g_ -> h_ -> (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_
+ GHC.Tuple: [(,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)] :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> r -> s -> t -> u -> v -> w -> x -> y -> z -> a_ -> b_ -> c_ -> d_ -> e_ -> f_ -> g_ -> h_ -> i_ -> (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_
+ GHC.Tuple: [(,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)] :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> r -> s -> t -> u -> v -> w -> x -> y -> z -> a_ -> b_ -> c_ -> d_ -> e_ -> f_ -> g_ -> h_ -> i_ -> j_ -> (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_
+ GHC.Tuple: [(,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)] :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> r -> s -> t -> u -> v -> w -> x -> y -> z -> a_ -> b_ -> c_ -> d_ -> e_ -> f_ -> g_ -> h_ -> i_ -> j_ -> k_ -> (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_
+ GHC.Tuple: [(,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)] :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> r -> s -> t -> u -> v -> w -> x -> y -> z -> a_ -> b_ -> c_ -> d_ -> e_ -> f_ -> g_ -> h_ -> i_ -> j_ -> k_ -> l_ -> (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_
+ GHC.Tuple: [(,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)] :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> r -> s -> t -> u -> v -> w -> x -> y -> z -> a_ -> b_ -> c_ -> d_ -> e_ -> f_ -> g_ -> h_ -> i_ -> j_ -> k_ -> l_ -> m_ -> (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_
+ GHC.Tuple: [(,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)] :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> r -> s -> t -> u -> v -> w -> x -> y -> z -> a_ -> b_ -> c_ -> d_ -> e_ -> f_ -> g_ -> h_ -> i_ -> j_ -> k_ -> l_ -> m_ -> n_ -> (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_
+ GHC.Tuple: [(,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)] :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> r -> s -> t -> u -> v -> w -> x -> y -> z -> a_ -> b_ -> c_ -> d_ -> e_ -> f_ -> g_ -> h_ -> i_ -> j_ -> k_ -> l_ -> m_ -> n_ -> o_ -> (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_
+ GHC.Tuple: [(,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)] :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> r -> s -> t -> u -> v -> w -> x -> y -> z -> a_ -> b_ -> c_ -> d_ -> e_ -> f_ -> g_ -> h_ -> i_ -> j_ -> k_ -> l_ -> m_ -> n_ -> o_ -> p_ -> (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_
+ GHC.Tuple: [(,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)] :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> r -> s -> t -> u -> v -> w -> x -> y -> z -> a_ -> b_ -> c_ -> d_ -> e_ -> f_ -> g_ -> h_ -> i_ -> j_ -> k_ -> l_ -> m_ -> n_ -> o_ -> p_ -> q_ -> (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_
+ GHC.Tuple: [(,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)] :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> r -> s -> t -> u -> v -> w -> x -> y -> z -> a_ -> b_ -> c_ -> d_ -> e_ -> f_ -> g_ -> h_ -> i_ -> j_ -> k_ -> l_ -> m_ -> n_ -> o_ -> p_ -> q_ -> r_ -> (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_
+ GHC.Tuple: [(,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)] :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> r -> s -> t -> u -> v -> w -> x -> y -> z -> a_ -> b_ -> c_ -> d_ -> e_ -> f_ -> g_ -> h_ -> i_ -> j_ -> k_ -> l_ -> m_ -> n_ -> o_ -> p_ -> q_ -> r_ -> s_ -> (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_
+ GHC.Tuple: [(,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)] :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> r -> s -> t -> u -> v -> w -> x -> y -> z -> a_ -> b_ -> c_ -> d_ -> e_ -> f_ -> g_ -> h_ -> i_ -> j_ -> k_ -> l_ -> m_ -> n_ -> o_ -> p_ -> q_ -> r_ -> s_ -> t_ -> (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_
+ GHC.Tuple: [(,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)] :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> r -> s -> t -> u -> v -> w -> x -> y -> z -> a_ -> b_ -> c_ -> d_ -> e_ -> f_ -> g_ -> h_ -> i_ -> j_ -> k_ -> l_ -> m_ -> n_ -> o_ -> p_ -> q_ -> r_ -> s_ -> t_ -> u_ -> (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_
+ GHC.Tuple: [(,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)] :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> r -> s -> t -> u -> v -> w -> x -> y -> z -> a_ -> b_ -> c_ -> d_ -> e_ -> f_ -> g_ -> h_ -> i_ -> j_ -> k_ -> l_ -> m_ -> n_ -> o_ -> p_ -> q_ -> r_ -> s_ -> t_ -> u_ -> v_ -> (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_
+ GHC.Tuple: [(,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)] :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> r -> s -> t -> u -> v -> w -> x -> y -> z -> a_ -> b_ -> c_ -> d_ -> e_ -> f_ -> g_ -> h_ -> i_ -> j_ -> k_ -> l_ -> m_ -> n_ -> o_ -> p_ -> q_ -> r_ -> s_ -> t_ -> u_ -> v_ -> w_ -> (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_
+ GHC.Tuple: [(,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)] :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> r -> s -> t -> u -> v -> w -> x -> y -> z -> a_ -> b_ -> c_ -> d_ -> e_ -> f_ -> g_ -> h_ -> i_ -> j_ -> k_ -> l_ -> m_ -> n_ -> o_ -> p_ -> q_ -> r_ -> s_ -> t_ -> u_ -> v_ -> w_ -> x_ -> (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_
+ GHC.Tuple: [(,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)] :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> r -> s -> t -> u -> v -> w -> x -> y -> z -> a_ -> b_ -> c_ -> d_ -> e_ -> f_ -> g_ -> h_ -> i_ -> j_ -> k_ -> l_ -> m_ -> n_ -> o_ -> p_ -> q_ -> r_ -> s_ -> t_ -> u_ -> v_ -> w_ -> x_ -> y_ -> (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_
+ GHC.Tuple: [(,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)] :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> r -> s -> t -> u -> v -> w -> x -> y -> z -> a_ -> b_ -> c_ -> d_ -> e_ -> f_ -> g_ -> h_ -> i_ -> j_ -> k_ -> l_ -> m_ -> n_ -> o_ -> p_ -> q_ -> r_ -> s_ -> t_ -> u_ -> v_ -> w_ -> x_ -> y_ -> z_ -> (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_
+ GHC.Tuple: [(,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)] :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> r -> s -> t -> u -> v -> w -> x -> y -> z -> a_ -> b_ -> c_ -> d_ -> e_ -> f_ -> g_ -> h_ -> i_ -> j_ -> k_ -> l_ -> m_ -> n_ -> o_ -> p_ -> q_ -> r_ -> s_ -> t_ -> u_ -> v_ -> w_ -> x_ -> y_ -> z_ -> a__ -> (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__
+ GHC.Tuple: [(,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)] :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> r -> s -> t -> u -> v -> w -> x -> y -> z -> a_ -> b_ -> c_ -> d_ -> e_ -> f_ -> g_ -> h_ -> i_ -> j_ -> k_ -> l_ -> m_ -> n_ -> o_ -> p_ -> q_ -> r_ -> s_ -> t_ -> u_ -> v_ -> w_ -> x_ -> y_ -> z_ -> a__ -> b__ -> (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__
+ GHC.Tuple: [(,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)] :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> r -> s -> t -> u -> v -> w -> x -> y -> z -> a_ -> b_ -> c_ -> d_ -> e_ -> f_ -> g_ -> h_ -> i_ -> j_ -> k_ -> l_ -> m_ -> n_ -> o_ -> p_ -> q_ -> r_ -> s_ -> t_ -> u_ -> v_ -> w_ -> x_ -> y_ -> z_ -> a__ -> b__ -> c__ -> (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__
+ GHC.Tuple: [(,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)] :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> r -> s -> t -> u -> v -> w -> x -> y -> z -> a_ -> b_ -> c_ -> d_ -> e_ -> f_ -> g_ -> h_ -> i_ -> j_ -> k_ -> l_ -> m_ -> n_ -> o_ -> p_ -> q_ -> r_ -> s_ -> t_ -> u_ -> v_ -> w_ -> x_ -> y_ -> z_ -> a__ -> b__ -> c__ -> d__ -> (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__
+ GHC.Tuple: [(,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)] :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> r -> s -> t -> u -> v -> w -> x -> y -> z -> a_ -> b_ -> c_ -> d_ -> e_ -> f_ -> g_ -> h_ -> i_ -> j_ -> k_ -> l_ -> m_ -> n_ -> o_ -> p_ -> q_ -> r_ -> s_ -> t_ -> u_ -> v_ -> w_ -> x_ -> y_ -> z_ -> a__ -> b__ -> c__ -> d__ -> e__ -> (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__
+ GHC.Tuple: [(,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)] :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> r -> s -> t -> u -> v -> w -> x -> y -> z -> a_ -> b_ -> c_ -> d_ -> e_ -> f_ -> g_ -> h_ -> i_ -> j_ -> k_ -> l_ -> m_ -> n_ -> o_ -> p_ -> q_ -> r_ -> s_ -> t_ -> u_ -> v_ -> w_ -> x_ -> y_ -> z_ -> a__ -> b__ -> c__ -> d__ -> e__ -> f__ -> (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__
+ GHC.Tuple: [(,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)] :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> r -> s -> t -> u -> v -> w -> x -> y -> z -> a_ -> b_ -> c_ -> d_ -> e_ -> f_ -> g_ -> h_ -> i_ -> j_ -> k_ -> l_ -> m_ -> n_ -> o_ -> p_ -> q_ -> r_ -> s_ -> t_ -> u_ -> v_ -> w_ -> x_ -> y_ -> z_ -> a__ -> b__ -> c__ -> d__ -> e__ -> f__ -> g__ -> (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__
+ GHC.Tuple: [(,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)] :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> r -> s -> t -> u -> v -> w -> x -> y -> z -> a_ -> b_ -> c_ -> d_ -> e_ -> f_ -> g_ -> h_ -> i_ -> j_ -> k_ -> l_ -> m_ -> n_ -> o_ -> p_ -> q_ -> r_ -> s_ -> t_ -> u_ -> v_ -> w_ -> x_ -> y_ -> z_ -> a__ -> b__ -> c__ -> d__ -> e__ -> f__ -> g__ -> h__ -> (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__
+ GHC.Tuple: [(,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)] :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> r -> s -> t -> u -> v -> w -> x -> y -> z -> a_ -> b_ -> c_ -> d_ -> e_ -> f_ -> g_ -> h_ -> i_ -> j_ -> k_ -> l_ -> m_ -> n_ -> o_ -> p_ -> q_ -> r_ -> s_ -> t_ -> u_ -> v_ -> w_ -> x_ -> y_ -> z_ -> a__ -> b__ -> c__ -> d__ -> e__ -> f__ -> g__ -> h__ -> i__ -> (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__
+ GHC.Tuple: [(,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,)] :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> p -> q -> r -> s -> t -> u -> v -> w -> x -> y -> z -> a_ -> b_ -> c_ -> d_ -> e_ -> f_ -> g_ -> h_ -> i_ -> j_ -> k_ -> l_ -> m_ -> n_ -> o_ -> p_ -> q_ -> r_ -> s_ -> t_ -> u_ -> v_ -> w_ -> x_ -> y_ -> z_ -> a__ -> b__ -> c__ -> d__ -> e__ -> f__ -> g__ -> h__ -> i__ -> j__ -> (,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o p q r s t u v w x y z a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q_ r_ s_ t_ u_ v_ w_ x_ y_ z_ a__ b__ c__ d__ e__ f__ g__ h__ i__ j__
+ GHC.Types: [C#] :: Char# -> Char
+ GHC.Types: [D#] :: Double# -> Double
+ GHC.Types: [EQ] :: Ordering
+ GHC.Types: [F#] :: Float# -> Float
+ GHC.Types: [False] :: Bool
+ GHC.Types: [GT] :: Ordering
+ GHC.Types: [I#] :: Int# -> Int
+ GHC.Types: [IO] :: (State# RealWorld -> (# State# RealWorld, a #)) -> IO a
+ GHC.Types: [LT] :: Ordering
+ GHC.Types: [SPEC2] :: SPEC
+ GHC.Types: [SPEC] :: SPEC
+ GHC.Types: [True] :: Bool
+ GHC.Types: [W#] :: Word# -> Word
+ GHC.Types: data Coercible a b
- GHC.Prim: data Any k
+ GHC.Prim: data Any
- GHC.Prim: prefetchAddr0# :: Addr# -> Int# -> Addr#
+ GHC.Prim: prefetchAddr0# :: Addr# -> Int# -> State# s -> State# s
- GHC.Prim: prefetchAddr1# :: Addr# -> Int# -> Addr#
+ GHC.Prim: prefetchAddr1# :: Addr# -> Int# -> State# s -> State# s
- GHC.Prim: prefetchAddr2# :: Addr# -> Int# -> Addr#
+ GHC.Prim: prefetchAddr2# :: Addr# -> Int# -> State# s -> State# s
- GHC.Prim: prefetchAddr3# :: Addr# -> Int# -> Addr#
+ GHC.Prim: prefetchAddr3# :: Addr# -> Int# -> State# s -> State# s
- GHC.Prim: prefetchByteArray0# :: ByteArray# -> Int# -> ByteArray#
+ GHC.Prim: prefetchByteArray0# :: ByteArray# -> Int# -> State# s -> State# s
- GHC.Prim: prefetchByteArray1# :: ByteArray# -> Int# -> ByteArray#
+ GHC.Prim: prefetchByteArray1# :: ByteArray# -> Int# -> State# s -> State# s
- GHC.Prim: prefetchByteArray2# :: ByteArray# -> Int# -> ByteArray#
+ GHC.Prim: prefetchByteArray2# :: ByteArray# -> Int# -> State# s -> State# s
- GHC.Prim: prefetchByteArray3# :: ByteArray# -> Int# -> ByteArray#
+ GHC.Prim: prefetchByteArray3# :: ByteArray# -> Int# -> State# s -> State# s
- GHC.PrimopWrappers: prefetchAddr0# :: Addr# -> Int# -> Addr#
+ GHC.PrimopWrappers: prefetchAddr0# :: Addr# -> Int# -> State# s -> State# s
- GHC.PrimopWrappers: prefetchAddr1# :: Addr# -> Int# -> Addr#
+ GHC.PrimopWrappers: prefetchAddr1# :: Addr# -> Int# -> State# s -> State# s
- GHC.PrimopWrappers: prefetchAddr2# :: Addr# -> Int# -> Addr#
+ GHC.PrimopWrappers: prefetchAddr2# :: Addr# -> Int# -> State# s -> State# s
- GHC.PrimopWrappers: prefetchAddr3# :: Addr# -> Int# -> Addr#
+ GHC.PrimopWrappers: prefetchAddr3# :: Addr# -> Int# -> State# s -> State# s
- GHC.PrimopWrappers: prefetchByteArray0# :: ByteArray# -> Int# -> ByteArray#
+ GHC.PrimopWrappers: prefetchByteArray0# :: ByteArray# -> Int# -> State# s -> State# s
- GHC.PrimopWrappers: prefetchByteArray1# :: ByteArray# -> Int# -> ByteArray#
+ GHC.PrimopWrappers: prefetchByteArray1# :: ByteArray# -> Int# -> State# s -> State# s
- GHC.PrimopWrappers: prefetchByteArray2# :: ByteArray# -> Int# -> ByteArray#
+ GHC.PrimopWrappers: prefetchByteArray2# :: ByteArray# -> Int# -> State# s -> State# s
- GHC.PrimopWrappers: prefetchByteArray3# :: ByteArray# -> Int# -> ByteArray#
+ GHC.PrimopWrappers: prefetchByteArray3# :: ByteArray# -> Int# -> State# s -> State# s
Files
- GHC/Classes.hs +4/−1
- GHC/Debug.hs +2/−1
- GHC/IntWord64.hs +0/−1
- GHC/Magic.hs +16/−7
- GHC/Prim.hs +6597/−6269
- GHC/PrimopWrappers.hs +137/−17
- GHC/Types.hs +35/−8
- cbits/atomic.c +320/−0
- cbits/clz.c +41/−0
- cbits/ctz.c +57/−0
- cbits/popcnt.c +7/−2
- ghc-prim.cabal +9/−10
GHC/Classes.hs view
@@ -17,7 +17,6 @@ -- ----------------------------------------------------------------------------- --- #hide module GHC.Classes where -- GHC.Magic is used in some derived instances@@ -84,7 +83,9 @@ => Eq (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) instance (Eq a) => Eq [a] where+ {-# SPECIALISE instance Eq [[Char]] #-} {-# SPECIALISE instance Eq [Char] #-}+ {-# SPECIALISE instance Eq [Int] #-} [] == [] = True (x:xs) == (y:ys) = x == y && xs == ys _xs == _ys = False@@ -182,7 +183,9 @@ => Ord (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) instance (Ord a) => Ord [a] where+ {-# SPECIALISE instance Ord [[Char]] #-} {-# SPECIALISE instance Ord [Char] #-}+ {-# SPECIALISE instance Ord [Int] #-} compare [] [] = EQ compare [] (_:_) = LT compare (_:_) [] = GT
GHC/Debug.hs view
@@ -1,4 +1,5 @@-{-# LANGUAGE MagicHash, NoImplicitPrelude, UnboxedTuples, UnliftedFFITypes, Trustworthy #-}+{-# LANGUAGE Trustworthy #-}+{-# LANGUAGE MagicHash, NoImplicitPrelude, UnboxedTuples, UnliftedFFITypes #-} module GHC.Debug ( debugLn, debugErrLn ) where
GHC/IntWord64.hs view
@@ -17,7 +17,6 @@ #include "MachDeps.h" --- #hide module GHC.IntWord64 ( #if WORD_SIZE_IN_BITS < 64 Int64#, Word64#, module GHC.IntWord64
GHC/Magic.hs view
@@ -17,17 +17,17 @@ -- ----------------------------------------------------------------------------- -module GHC.Magic ( inline, lazy ) where+module GHC.Magic ( inline, lazy, oneShot ) where --- | The call '(inline f)' arranges that 'f' is inlined, regardless of--- its size. More precisely, the call '(inline f)' rewrites to the--- right-hand side of 'f'\'s definition. This allows the programmer to+-- | The call @inline f@ arranges that 'f' is inlined, regardless of+-- its size. More precisely, the call @inline f@ rewrites to the+-- right-hand side of @f@'s definition. This allows the programmer to -- control inlining from a particular call site rather than the -- definition site of the function (c.f. 'INLINE' pragmas). -- -- This inlining occurs regardless of the argument to the call or the--- size of 'f'\'s definition; it is unconditional. The main caveat is--- that 'f'\'s definition must be visible to the compiler; it is+-- size of @f@'s definition; it is unconditional. The main caveat is+-- that @f@'s definition must be visible to the compiler; it is -- therefore recommended to mark the function with an 'INLINABLE' -- pragma at its definition so that GHC guarantees to record its -- unfolding regardless of size.@@ -39,7 +39,7 @@ inline x = x -- | The 'lazy' function restrains strictness analysis a little. The--- call '(lazy e)' means the same as 'e', but 'lazy' has a magical+-- call @lazy e@ means the same as 'e', but 'lazy' has a magical -- property so far as strictness analysis is concerned: it is lazy in -- its first argument, even though its semantics is strict. After -- strictness analysis has run, calls to 'lazy' are inlined to be the@@ -64,3 +64,12 @@ -- sees it as lazy. Then the worker/wrapper phase inlines it. -- Result: happiness ++-- | The 'oneShot' function can be used to give a hint to the compiler that its+-- argument will be called at most once, which may (or may not) enable certain+-- optimizations. It can be useful to improve the performance of code in continuation+-- passing style.+oneShot :: (a -> b) -> (a -> b)+oneShot f = f+-- Implementation note: This is wired in in MkId.lhs, so the code here is+-- mostly there to have a place for the documentation.
GHC/Prim.hs view
@@ -17,6275 +17,6603 @@ -- module directly. -- ------------------------------------------------------------------------------{-# LANGUAGE MagicHash, MultiParamTypeClasses, NoImplicitPrelude, UnboxedTuples #-}-module GHC.Prim (- --- * The word size story.--- |Haskell98 specifies that signed integers (type @Int@)--- must contain at least 30 bits. GHC always implements @Int@ using the primitive type @Int\#@, whose size equals--- the @MachDeps.h@ constant @WORD\_SIZE\_IN\_BITS@.--- This is normally set based on the @config.h@ parameter--- @SIZEOF\_HSWORD@, i.e., 32 bits on 32-bit machines, 64--- bits on 64-bit machines. However, it can also be explicitly--- set to a smaller number, e.g., 31 bits, to allow the--- possibility of using tag bits. Currently GHC itself has only--- 32-bit and 64-bit variants, but 30 or 31-bit code can be--- exported as an external core file for use in other back ends.--- --- GHC also implements a primitive unsigned integer type @Word\#@ which always has the same number of bits as @Int\#@.--- --- In addition, GHC supports families of explicit-sized integers--- and words at 8, 16, 32, and 64 bits, with the usual--- arithmetic operations, comparisons, and a range of--- conversions. The 8-bit and 16-bit sizes are always--- represented as @Int\#@ and @Word\#@, and the--- operations implemented in terms of the the primops on these--- types, with suitable range restrictions on the results (using--- the @narrow$n$Int\#@ and @narrow$n$Word\#@ families--- of primops. The 32-bit sizes are represented using @Int\#@ and @Word\#@ when @WORD\_SIZE\_IN\_BITS@--- $\geq$ 32; otherwise, these are represented using distinct--- primitive types @Int32\#@ and @Word32\#@. These (when--- needed) have a complete set of corresponding operations;--- however, nearly all of these are implemented as external C--- functions rather than as primops. Exactly the same story--- applies to the 64-bit sizes. All of these details are hidden--- under the @PrelInt@ and @PrelWord@ modules, which use--- @\#if@-defs to invoke the appropriate types and--- operators.--- --- Word size also matters for the families of primops for--- indexing\/reading\/writing fixed-size quantities at offsets--- from an array base, address, or foreign pointer. Here, a--- slightly different approach is taken. The names of these--- primops are fixed, but their /types/ vary according to--- the value of @WORD\_SIZE\_IN\_BITS@. For example, if word--- size is at least 32 bits then an operator like--- @indexInt32Array\#@ has type @ByteArray\# -> Int\# -> Int\#@; otherwise it has type @ByteArray\# -> Int\# -> Int32\#@. This approach confines the necessary @\#if@-defs to this file; no conditional compilation is needed--- in the files that expose these primops.--- --- Finally, there are strongly deprecated primops for coercing--- between @Addr\#@, the primitive type of machine--- addresses, and @Int\#@. These are pretty bogus anyway,--- but will work on existing 32-bit and 64-bit GHC targets; they--- are completely bogus when tag bits are used in @Int\#@,--- so are not available in this case. --- --- * Char#--- |Operations on 31-bit characters.--- Char#,- gtChar#,- geChar#,- eqChar#,- neChar#,- ltChar#,- leChar#,- ord#,- --- * Int#--- |Operations on native-size integers (30+ bits).--- Int#,- (+#),- (-#),- (*#),- mulIntMayOflo#,- quotInt#,- remInt#,- quotRemInt#,- andI#,- orI#,- xorI#,- notI#,- negateInt#,- addIntC#,- subIntC#,- (>#),- (>=#),- (==#),- (/=#),- (<#),- (<=#),- chr#,- int2Word#,- int2Float#,- int2Double#,- word2Float#,- word2Double#,- uncheckedIShiftL#,- uncheckedIShiftRA#,- uncheckedIShiftRL#,- --- * Word#--- |Operations on native-sized unsigned words (30+ bits).--- Word#,- plusWord#,- plusWord2#,- minusWord#,- timesWord#,- timesWord2#,- quotWord#,- remWord#,- quotRemWord#,- quotRemWord2#,- and#,- or#,- xor#,- not#,- uncheckedShiftL#,- uncheckedShiftRL#,- word2Int#,- gtWord#,- geWord#,- eqWord#,- neWord#,- ltWord#,- leWord#,- popCnt8#,- popCnt16#,- popCnt32#,- popCnt64#,- popCnt#,- byteSwap16#,- byteSwap32#,- byteSwap64#,- byteSwap#,- --- * Narrowings--- |Explicit narrowing of native-sized ints or words.--- narrow8Int#,- narrow16Int#,- narrow32Int#,- narrow8Word#,- narrow16Word#,- narrow32Word#,- --- * Double#--- |Operations on double-precision (64 bit) floating-point numbers.--- Double#,- (>##),- (>=##),- (==##),- (/=##),- (<##),- (<=##),- (+##),- (-##),- (*##),- (/##),- negateDouble#,- double2Int#,- double2Float#,- expDouble#,- logDouble#,- sqrtDouble#,- sinDouble#,- cosDouble#,- tanDouble#,- asinDouble#,- acosDouble#,- atanDouble#,- sinhDouble#,- coshDouble#,- tanhDouble#,- (**##),- decodeDouble_2Int#,- --- * Float#--- |Operations on single-precision (32-bit) floating-point numbers.--- Float#,- gtFloat#,- geFloat#,- eqFloat#,- neFloat#,- ltFloat#,- leFloat#,- plusFloat#,- minusFloat#,- timesFloat#,- divideFloat#,- negateFloat#,- float2Int#,- expFloat#,- logFloat#,- sqrtFloat#,- sinFloat#,- cosFloat#,- tanFloat#,- asinFloat#,- acosFloat#,- atanFloat#,- sinhFloat#,- coshFloat#,- tanhFloat#,- powerFloat#,- float2Double#,- decodeFloat_Int#,- --- * Arrays--- |Operations on @Array\#@.--- Array#,- MutableArray#,- newArray#,- sameMutableArray#,- readArray#,- writeArray#,- sizeofArray#,- sizeofMutableArray#,- indexArray#,- unsafeFreezeArray#,- unsafeThawArray#,- copyArray#,- copyMutableArray#,- cloneArray#,- cloneMutableArray#,- freezeArray#,- thawArray#,- casArray#,- --- * Byte Arrays--- |Operations on @ByteArray\#@. A @ByteArray\#@ is a just a region of--- raw memory in the garbage-collected heap, which is not--- scanned for pointers. It carries its own size (in bytes).--- There are--- three sets of operations for accessing byte array contents:--- index for reading from immutable byte arrays, and read\/write--- for mutable byte arrays. Each set contains operations for a--- range of useful primitive data types. Each operation takes--- an offset measured in terms of the size of the primitive type--- being read or written.--- ByteArray#,- MutableByteArray#,- newByteArray#,- newPinnedByteArray#,- newAlignedPinnedByteArray#,- byteArrayContents#,- sameMutableByteArray#,- unsafeFreezeByteArray#,- sizeofByteArray#,- sizeofMutableByteArray#,- indexCharArray#,- indexWideCharArray#,- indexIntArray#,- indexWordArray#,- indexAddrArray#,- indexFloatArray#,- indexDoubleArray#,- indexStablePtrArray#,- indexInt8Array#,- indexInt16Array#,- indexInt32Array#,- indexInt64Array#,- indexWord8Array#,- indexWord16Array#,- indexWord32Array#,- indexWord64Array#,- readCharArray#,- readWideCharArray#,- readIntArray#,- readWordArray#,- readAddrArray#,- readFloatArray#,- readDoubleArray#,- readStablePtrArray#,- readInt8Array#,- readInt16Array#,- readInt32Array#,- readInt64Array#,- readWord8Array#,- readWord16Array#,- readWord32Array#,- readWord64Array#,- writeCharArray#,- writeWideCharArray#,- writeIntArray#,- writeWordArray#,- writeAddrArray#,- writeFloatArray#,- writeDoubleArray#,- writeStablePtrArray#,- writeInt8Array#,- writeInt16Array#,- writeInt32Array#,- writeInt64Array#,- writeWord8Array#,- writeWord16Array#,- writeWord32Array#,- writeWord64Array#,- copyByteArray#,- copyMutableByteArray#,- copyByteArrayToAddr#,- copyMutableByteArrayToAddr#,- copyAddrToByteArray#,- setByteArray#,- casIntArray#,- fetchAddIntArray#,- --- * Arrays of arrays--- |Operations on @ArrayArray\#@. An @ArrayArray\#@ contains references to {\em unpointed}--- arrays, such as @ByteArray\#s@. Hence, it is not parameterised by the element types,--- just like a @ByteArray\#@, but it needs to be scanned during GC, just like an @Array#@.--- We represent an @ArrayArray\#@ exactly as a @Array\#@, but provide element-type-specific--- indexing, reading, and writing.--- ArrayArray#,- MutableArrayArray#,- newArrayArray#,- sameMutableArrayArray#,- unsafeFreezeArrayArray#,- sizeofArrayArray#,- sizeofMutableArrayArray#,- indexByteArrayArray#,- indexArrayArrayArray#,- readByteArrayArray#,- readMutableByteArrayArray#,- readArrayArrayArray#,- readMutableArrayArrayArray#,- writeByteArrayArray#,- writeMutableByteArrayArray#,- writeArrayArrayArray#,- writeMutableArrayArrayArray#,- copyArrayArray#,- copyMutableArrayArray#,- --- * Addr#--- |--- Addr#,- nullAddr#,- plusAddr#,- minusAddr#,- remAddr#,- addr2Int#,- int2Addr#,- gtAddr#,- geAddr#,- eqAddr#,- neAddr#,- ltAddr#,- leAddr#,- indexCharOffAddr#,- indexWideCharOffAddr#,- indexIntOffAddr#,- indexWordOffAddr#,- indexAddrOffAddr#,- indexFloatOffAddr#,- indexDoubleOffAddr#,- indexStablePtrOffAddr#,- indexInt8OffAddr#,- indexInt16OffAddr#,- indexInt32OffAddr#,- indexInt64OffAddr#,- indexWord8OffAddr#,- indexWord16OffAddr#,- indexWord32OffAddr#,- indexWord64OffAddr#,- readCharOffAddr#,- readWideCharOffAddr#,- readIntOffAddr#,- readWordOffAddr#,- readAddrOffAddr#,- readFloatOffAddr#,- readDoubleOffAddr#,- readStablePtrOffAddr#,- readInt8OffAddr#,- readInt16OffAddr#,- readInt32OffAddr#,- readInt64OffAddr#,- readWord8OffAddr#,- readWord16OffAddr#,- readWord32OffAddr#,- readWord64OffAddr#,- writeCharOffAddr#,- writeWideCharOffAddr#,- writeIntOffAddr#,- writeWordOffAddr#,- writeAddrOffAddr#,- writeFloatOffAddr#,- writeDoubleOffAddr#,- writeStablePtrOffAddr#,- writeInt8OffAddr#,- writeInt16OffAddr#,- writeInt32OffAddr#,- writeInt64OffAddr#,- writeWord8OffAddr#,- writeWord16OffAddr#,- writeWord32OffAddr#,- writeWord64OffAddr#,- --- * Mutable variables--- |Operations on MutVar\#s.--- MutVar#,- newMutVar#,- readMutVar#,- writeMutVar#,- sameMutVar#,- atomicModifyMutVar#,- casMutVar#,- --- * Exceptions--- |--- catch#,- raise#,- raiseIO#,- maskAsyncExceptions#,- maskUninterruptible#,- unmaskAsyncExceptions#,- getMaskingState#,- --- * STM-accessible Mutable Variables--- |--- TVar#,- atomically#,- retry#,- catchRetry#,- catchSTM#,- check#,- newTVar#,- readTVar#,- readTVarIO#,- writeTVar#,- sameTVar#,- --- * Synchronized Mutable Variables--- |Operations on @MVar\#@s. --- MVar#,- newMVar#,- takeMVar#,- tryTakeMVar#,- putMVar#,- tryPutMVar#,- readMVar#,- tryReadMVar#,- sameMVar#,- isEmptyMVar#,- --- * Delay\/wait operations--- |--- delay#,- waitRead#,- waitWrite#,- --- * Concurrency primitives--- |--- State#,- RealWorld,- ThreadId#,- fork#,- forkOn#,- killThread#,- yield#,- myThreadId#,- labelThread#,- isCurrentThreadBound#,- noDuplicate#,- threadStatus#,- --- * Weak pointers--- |--- Weak#,- mkWeak#,- mkWeakNoFinalizer#,- addCFinalizerToWeak#,- deRefWeak#,- finalizeWeak#,- touch#,- --- * Stable pointers and names--- |--- StablePtr#,- StableName#,- makeStablePtr#,- deRefStablePtr#,- eqStablePtr#,- makeStableName#,- eqStableName#,- stableNameToInt#,- --- * Unsafe pointer equality--- |--- reallyUnsafePtrEquality#,- --- * Parallelism--- |--- par#,- spark#,- seq#,- getSpark#,- numSparks#,- parGlobal#,- parLocal#,- parAt#,- parAtAbs#,- parAtRel#,- parAtForNow#,- --- * Tag to enum stuff--- |Convert back and forth between values of enumerated types--- and small integers.--- dataToTag#,- tagToEnum#,- --- * Bytecode operations--- |Support for the bytecode interpreter and linker.--- BCO#,- addrToAny#,- mkApUpd0#,- newBCO#,- unpackClosure#,- getApStackVal#,- --- * Misc--- |These aren\'t nearly as wired in as Etc...--- getCCSOf#,- getCurrentCCS#,- --- * Etc--- |Miscellaneous built-ins--- Proxy#,- proxy#,- seq,- Any,- AnyK,- unsafeCoerce#,- traceEvent#,- traceMarker#,- --- * Safe coercions--- |--- coerce,- Coercible,- --- * SIMD Vectors--- |Operations on SIMD vectors.--- Int8X16#,- Int16X8#,- Int32X4#,- Int64X2#,- Int8X32#,- Int16X16#,- Int32X8#,- Int64X4#,- Int8X64#,- Int16X32#,- Int32X16#,- Int64X8#,- Word8X16#,- Word16X8#,- Word32X4#,- Word64X2#,- Word8X32#,- Word16X16#,- Word32X8#,- Word64X4#,- Word8X64#,- Word16X32#,- Word32X16#,- Word64X8#,- FloatX4#,- DoubleX2#,- FloatX8#,- DoubleX4#,- FloatX16#,- DoubleX8#,- broadcastInt8X16#,- broadcastInt16X8#,- broadcastInt32X4#,- broadcastInt64X2#,- broadcastInt8X32#,- broadcastInt16X16#,- broadcastInt32X8#,- broadcastInt64X4#,- broadcastInt8X64#,- broadcastInt16X32#,- broadcastInt32X16#,- broadcastInt64X8#,- broadcastWord8X16#,- broadcastWord16X8#,- broadcastWord32X4#,- broadcastWord64X2#,- broadcastWord8X32#,- broadcastWord16X16#,- broadcastWord32X8#,- broadcastWord64X4#,- broadcastWord8X64#,- broadcastWord16X32#,- broadcastWord32X16#,- broadcastWord64X8#,- broadcastFloatX4#,- broadcastDoubleX2#,- broadcastFloatX8#,- broadcastDoubleX4#,- broadcastFloatX16#,- broadcastDoubleX8#,- packInt8X16#,- packInt16X8#,- packInt32X4#,- packInt64X2#,- packInt8X32#,- packInt16X16#,- packInt32X8#,- packInt64X4#,- packInt8X64#,- packInt16X32#,- packInt32X16#,- packInt64X8#,- packWord8X16#,- packWord16X8#,- packWord32X4#,- packWord64X2#,- packWord8X32#,- packWord16X16#,- packWord32X8#,- packWord64X4#,- packWord8X64#,- packWord16X32#,- packWord32X16#,- packWord64X8#,- packFloatX4#,- packDoubleX2#,- packFloatX8#,- packDoubleX4#,- packFloatX16#,- packDoubleX8#,- unpackInt8X16#,- unpackInt16X8#,- unpackInt32X4#,- unpackInt64X2#,- unpackInt8X32#,- unpackInt16X16#,- unpackInt32X8#,- unpackInt64X4#,- unpackInt8X64#,- unpackInt16X32#,- unpackInt32X16#,- unpackInt64X8#,- unpackWord8X16#,- unpackWord16X8#,- unpackWord32X4#,- unpackWord64X2#,- unpackWord8X32#,- unpackWord16X16#,- unpackWord32X8#,- unpackWord64X4#,- unpackWord8X64#,- unpackWord16X32#,- unpackWord32X16#,- unpackWord64X8#,- unpackFloatX4#,- unpackDoubleX2#,- unpackFloatX8#,- unpackDoubleX4#,- unpackFloatX16#,- unpackDoubleX8#,- insertInt8X16#,- insertInt16X8#,- insertInt32X4#,- insertInt64X2#,- insertInt8X32#,- insertInt16X16#,- insertInt32X8#,- insertInt64X4#,- insertInt8X64#,- insertInt16X32#,- insertInt32X16#,- insertInt64X8#,- insertWord8X16#,- insertWord16X8#,- insertWord32X4#,- insertWord64X2#,- insertWord8X32#,- insertWord16X16#,- insertWord32X8#,- insertWord64X4#,- insertWord8X64#,- insertWord16X32#,- insertWord32X16#,- insertWord64X8#,- insertFloatX4#,- insertDoubleX2#,- insertFloatX8#,- insertDoubleX4#,- insertFloatX16#,- insertDoubleX8#,- plusInt8X16#,- plusInt16X8#,- plusInt32X4#,- plusInt64X2#,- plusInt8X32#,- plusInt16X16#,- plusInt32X8#,- plusInt64X4#,- plusInt8X64#,- plusInt16X32#,- plusInt32X16#,- plusInt64X8#,- plusWord8X16#,- plusWord16X8#,- plusWord32X4#,- plusWord64X2#,- plusWord8X32#,- plusWord16X16#,- plusWord32X8#,- plusWord64X4#,- plusWord8X64#,- plusWord16X32#,- plusWord32X16#,- plusWord64X8#,- plusFloatX4#,- plusDoubleX2#,- plusFloatX8#,- plusDoubleX4#,- plusFloatX16#,- plusDoubleX8#,- minusInt8X16#,- minusInt16X8#,- minusInt32X4#,- minusInt64X2#,- minusInt8X32#,- minusInt16X16#,- minusInt32X8#,- minusInt64X4#,- minusInt8X64#,- minusInt16X32#,- minusInt32X16#,- minusInt64X8#,- minusWord8X16#,- minusWord16X8#,- minusWord32X4#,- minusWord64X2#,- minusWord8X32#,- minusWord16X16#,- minusWord32X8#,- minusWord64X4#,- minusWord8X64#,- minusWord16X32#,- minusWord32X16#,- minusWord64X8#,- minusFloatX4#,- minusDoubleX2#,- minusFloatX8#,- minusDoubleX4#,- minusFloatX16#,- minusDoubleX8#,- timesInt8X16#,- timesInt16X8#,- timesInt32X4#,- timesInt64X2#,- timesInt8X32#,- timesInt16X16#,- timesInt32X8#,- timesInt64X4#,- timesInt8X64#,- timesInt16X32#,- timesInt32X16#,- timesInt64X8#,- timesWord8X16#,- timesWord16X8#,- timesWord32X4#,- timesWord64X2#,- timesWord8X32#,- timesWord16X16#,- timesWord32X8#,- timesWord64X4#,- timesWord8X64#,- timesWord16X32#,- timesWord32X16#,- timesWord64X8#,- timesFloatX4#,- timesDoubleX2#,- timesFloatX8#,- timesDoubleX4#,- timesFloatX16#,- timesDoubleX8#,- divideFloatX4#,- divideDoubleX2#,- divideFloatX8#,- divideDoubleX4#,- divideFloatX16#,- divideDoubleX8#,- quotInt8X16#,- quotInt16X8#,- quotInt32X4#,- quotInt64X2#,- quotInt8X32#,- quotInt16X16#,- quotInt32X8#,- quotInt64X4#,- quotInt8X64#,- quotInt16X32#,- quotInt32X16#,- quotInt64X8#,- quotWord8X16#,- quotWord16X8#,- quotWord32X4#,- quotWord64X2#,- quotWord8X32#,- quotWord16X16#,- quotWord32X8#,- quotWord64X4#,- quotWord8X64#,- quotWord16X32#,- quotWord32X16#,- quotWord64X8#,- remInt8X16#,- remInt16X8#,- remInt32X4#,- remInt64X2#,- remInt8X32#,- remInt16X16#,- remInt32X8#,- remInt64X4#,- remInt8X64#,- remInt16X32#,- remInt32X16#,- remInt64X8#,- remWord8X16#,- remWord16X8#,- remWord32X4#,- remWord64X2#,- remWord8X32#,- remWord16X16#,- remWord32X8#,- remWord64X4#,- remWord8X64#,- remWord16X32#,- remWord32X16#,- remWord64X8#,- negateInt8X16#,- negateInt16X8#,- negateInt32X4#,- negateInt64X2#,- negateInt8X32#,- negateInt16X16#,- negateInt32X8#,- negateInt64X4#,- negateInt8X64#,- negateInt16X32#,- negateInt32X16#,- negateInt64X8#,- negateFloatX4#,- negateDoubleX2#,- negateFloatX8#,- negateDoubleX4#,- negateFloatX16#,- negateDoubleX8#,- indexInt8X16Array#,- indexInt16X8Array#,- indexInt32X4Array#,- indexInt64X2Array#,- indexInt8X32Array#,- indexInt16X16Array#,- indexInt32X8Array#,- indexInt64X4Array#,- indexInt8X64Array#,- indexInt16X32Array#,- indexInt32X16Array#,- indexInt64X8Array#,- indexWord8X16Array#,- indexWord16X8Array#,- indexWord32X4Array#,- indexWord64X2Array#,- indexWord8X32Array#,- indexWord16X16Array#,- indexWord32X8Array#,- indexWord64X4Array#,- indexWord8X64Array#,- indexWord16X32Array#,- indexWord32X16Array#,- indexWord64X8Array#,- indexFloatX4Array#,- indexDoubleX2Array#,- indexFloatX8Array#,- indexDoubleX4Array#,- indexFloatX16Array#,- indexDoubleX8Array#,- readInt8X16Array#,- readInt16X8Array#,- readInt32X4Array#,- readInt64X2Array#,- readInt8X32Array#,- readInt16X16Array#,- readInt32X8Array#,- readInt64X4Array#,- readInt8X64Array#,- readInt16X32Array#,- readInt32X16Array#,- readInt64X8Array#,- readWord8X16Array#,- readWord16X8Array#,- readWord32X4Array#,- readWord64X2Array#,- readWord8X32Array#,- readWord16X16Array#,- readWord32X8Array#,- readWord64X4Array#,- readWord8X64Array#,- readWord16X32Array#,- readWord32X16Array#,- readWord64X8Array#,- readFloatX4Array#,- readDoubleX2Array#,- readFloatX8Array#,- readDoubleX4Array#,- readFloatX16Array#,- readDoubleX8Array#,- writeInt8X16Array#,- writeInt16X8Array#,- writeInt32X4Array#,- writeInt64X2Array#,- writeInt8X32Array#,- writeInt16X16Array#,- writeInt32X8Array#,- writeInt64X4Array#,- writeInt8X64Array#,- writeInt16X32Array#,- writeInt32X16Array#,- writeInt64X8Array#,- writeWord8X16Array#,- writeWord16X8Array#,- writeWord32X4Array#,- writeWord64X2Array#,- writeWord8X32Array#,- writeWord16X16Array#,- writeWord32X8Array#,- writeWord64X4Array#,- writeWord8X64Array#,- writeWord16X32Array#,- writeWord32X16Array#,- writeWord64X8Array#,- writeFloatX4Array#,- writeDoubleX2Array#,- writeFloatX8Array#,- writeDoubleX4Array#,- writeFloatX16Array#,- writeDoubleX8Array#,- indexInt8X16OffAddr#,- indexInt16X8OffAddr#,- indexInt32X4OffAddr#,- indexInt64X2OffAddr#,- indexInt8X32OffAddr#,- indexInt16X16OffAddr#,- indexInt32X8OffAddr#,- indexInt64X4OffAddr#,- indexInt8X64OffAddr#,- indexInt16X32OffAddr#,- indexInt32X16OffAddr#,- indexInt64X8OffAddr#,- indexWord8X16OffAddr#,- indexWord16X8OffAddr#,- indexWord32X4OffAddr#,- indexWord64X2OffAddr#,- indexWord8X32OffAddr#,- indexWord16X16OffAddr#,- indexWord32X8OffAddr#,- indexWord64X4OffAddr#,- indexWord8X64OffAddr#,- indexWord16X32OffAddr#,- indexWord32X16OffAddr#,- indexWord64X8OffAddr#,- indexFloatX4OffAddr#,- indexDoubleX2OffAddr#,- indexFloatX8OffAddr#,- indexDoubleX4OffAddr#,- indexFloatX16OffAddr#,- indexDoubleX8OffAddr#,- readInt8X16OffAddr#,- readInt16X8OffAddr#,- readInt32X4OffAddr#,- readInt64X2OffAddr#,- readInt8X32OffAddr#,- readInt16X16OffAddr#,- readInt32X8OffAddr#,- readInt64X4OffAddr#,- readInt8X64OffAddr#,- readInt16X32OffAddr#,- readInt32X16OffAddr#,- readInt64X8OffAddr#,- readWord8X16OffAddr#,- readWord16X8OffAddr#,- readWord32X4OffAddr#,- readWord64X2OffAddr#,- readWord8X32OffAddr#,- readWord16X16OffAddr#,- readWord32X8OffAddr#,- readWord64X4OffAddr#,- readWord8X64OffAddr#,- readWord16X32OffAddr#,- readWord32X16OffAddr#,- readWord64X8OffAddr#,- readFloatX4OffAddr#,- readDoubleX2OffAddr#,- readFloatX8OffAddr#,- readDoubleX4OffAddr#,- readFloatX16OffAddr#,- readDoubleX8OffAddr#,- writeInt8X16OffAddr#,- writeInt16X8OffAddr#,- writeInt32X4OffAddr#,- writeInt64X2OffAddr#,- writeInt8X32OffAddr#,- writeInt16X16OffAddr#,- writeInt32X8OffAddr#,- writeInt64X4OffAddr#,- writeInt8X64OffAddr#,- writeInt16X32OffAddr#,- writeInt32X16OffAddr#,- writeInt64X8OffAddr#,- writeWord8X16OffAddr#,- writeWord16X8OffAddr#,- writeWord32X4OffAddr#,- writeWord64X2OffAddr#,- writeWord8X32OffAddr#,- writeWord16X16OffAddr#,- writeWord32X8OffAddr#,- writeWord64X4OffAddr#,- writeWord8X64OffAddr#,- writeWord16X32OffAddr#,- writeWord32X16OffAddr#,- writeWord64X8OffAddr#,- writeFloatX4OffAddr#,- writeDoubleX2OffAddr#,- writeFloatX8OffAddr#,- writeDoubleX4OffAddr#,- writeFloatX16OffAddr#,- writeDoubleX8OffAddr#,- indexInt8ArrayAsInt8X16#,- indexInt16ArrayAsInt16X8#,- indexInt32ArrayAsInt32X4#,- indexInt64ArrayAsInt64X2#,- indexInt8ArrayAsInt8X32#,- indexInt16ArrayAsInt16X16#,- indexInt32ArrayAsInt32X8#,- indexInt64ArrayAsInt64X4#,- indexInt8ArrayAsInt8X64#,- indexInt16ArrayAsInt16X32#,- indexInt32ArrayAsInt32X16#,- indexInt64ArrayAsInt64X8#,- indexWord8ArrayAsWord8X16#,- indexWord16ArrayAsWord16X8#,- indexWord32ArrayAsWord32X4#,- indexWord64ArrayAsWord64X2#,- indexWord8ArrayAsWord8X32#,- indexWord16ArrayAsWord16X16#,- indexWord32ArrayAsWord32X8#,- indexWord64ArrayAsWord64X4#,- indexWord8ArrayAsWord8X64#,- indexWord16ArrayAsWord16X32#,- indexWord32ArrayAsWord32X16#,- indexWord64ArrayAsWord64X8#,- indexFloatArrayAsFloatX4#,- indexDoubleArrayAsDoubleX2#,- indexFloatArrayAsFloatX8#,- indexDoubleArrayAsDoubleX4#,- indexFloatArrayAsFloatX16#,- indexDoubleArrayAsDoubleX8#,- readInt8ArrayAsInt8X16#,- readInt16ArrayAsInt16X8#,- readInt32ArrayAsInt32X4#,- readInt64ArrayAsInt64X2#,- readInt8ArrayAsInt8X32#,- readInt16ArrayAsInt16X16#,- readInt32ArrayAsInt32X8#,- readInt64ArrayAsInt64X4#,- readInt8ArrayAsInt8X64#,- readInt16ArrayAsInt16X32#,- readInt32ArrayAsInt32X16#,- readInt64ArrayAsInt64X8#,- readWord8ArrayAsWord8X16#,- readWord16ArrayAsWord16X8#,- readWord32ArrayAsWord32X4#,- readWord64ArrayAsWord64X2#,- readWord8ArrayAsWord8X32#,- readWord16ArrayAsWord16X16#,- readWord32ArrayAsWord32X8#,- readWord64ArrayAsWord64X4#,- readWord8ArrayAsWord8X64#,- readWord16ArrayAsWord16X32#,- readWord32ArrayAsWord32X16#,- readWord64ArrayAsWord64X8#,- readFloatArrayAsFloatX4#,- readDoubleArrayAsDoubleX2#,- readFloatArrayAsFloatX8#,- readDoubleArrayAsDoubleX4#,- readFloatArrayAsFloatX16#,- readDoubleArrayAsDoubleX8#,- writeInt8ArrayAsInt8X16#,- writeInt16ArrayAsInt16X8#,- writeInt32ArrayAsInt32X4#,- writeInt64ArrayAsInt64X2#,- writeInt8ArrayAsInt8X32#,- writeInt16ArrayAsInt16X16#,- writeInt32ArrayAsInt32X8#,- writeInt64ArrayAsInt64X4#,- writeInt8ArrayAsInt8X64#,- writeInt16ArrayAsInt16X32#,- writeInt32ArrayAsInt32X16#,- writeInt64ArrayAsInt64X8#,- writeWord8ArrayAsWord8X16#,- writeWord16ArrayAsWord16X8#,- writeWord32ArrayAsWord32X4#,- writeWord64ArrayAsWord64X2#,- writeWord8ArrayAsWord8X32#,- writeWord16ArrayAsWord16X16#,- writeWord32ArrayAsWord32X8#,- writeWord64ArrayAsWord64X4#,- writeWord8ArrayAsWord8X64#,- writeWord16ArrayAsWord16X32#,- writeWord32ArrayAsWord32X16#,- writeWord64ArrayAsWord64X8#,- writeFloatArrayAsFloatX4#,- writeDoubleArrayAsDoubleX2#,- writeFloatArrayAsFloatX8#,- writeDoubleArrayAsDoubleX4#,- writeFloatArrayAsFloatX16#,- writeDoubleArrayAsDoubleX8#,- indexInt8OffAddrAsInt8X16#,- indexInt16OffAddrAsInt16X8#,- indexInt32OffAddrAsInt32X4#,- indexInt64OffAddrAsInt64X2#,- indexInt8OffAddrAsInt8X32#,- indexInt16OffAddrAsInt16X16#,- indexInt32OffAddrAsInt32X8#,- indexInt64OffAddrAsInt64X4#,- indexInt8OffAddrAsInt8X64#,- indexInt16OffAddrAsInt16X32#,- indexInt32OffAddrAsInt32X16#,- indexInt64OffAddrAsInt64X8#,- indexWord8OffAddrAsWord8X16#,- indexWord16OffAddrAsWord16X8#,- indexWord32OffAddrAsWord32X4#,- indexWord64OffAddrAsWord64X2#,- indexWord8OffAddrAsWord8X32#,- indexWord16OffAddrAsWord16X16#,- indexWord32OffAddrAsWord32X8#,- indexWord64OffAddrAsWord64X4#,- indexWord8OffAddrAsWord8X64#,- indexWord16OffAddrAsWord16X32#,- indexWord32OffAddrAsWord32X16#,- indexWord64OffAddrAsWord64X8#,- indexFloatOffAddrAsFloatX4#,- indexDoubleOffAddrAsDoubleX2#,- indexFloatOffAddrAsFloatX8#,- indexDoubleOffAddrAsDoubleX4#,- indexFloatOffAddrAsFloatX16#,- indexDoubleOffAddrAsDoubleX8#,- readInt8OffAddrAsInt8X16#,- readInt16OffAddrAsInt16X8#,- readInt32OffAddrAsInt32X4#,- readInt64OffAddrAsInt64X2#,- readInt8OffAddrAsInt8X32#,- readInt16OffAddrAsInt16X16#,- readInt32OffAddrAsInt32X8#,- readInt64OffAddrAsInt64X4#,- readInt8OffAddrAsInt8X64#,- readInt16OffAddrAsInt16X32#,- readInt32OffAddrAsInt32X16#,- readInt64OffAddrAsInt64X8#,- readWord8OffAddrAsWord8X16#,- readWord16OffAddrAsWord16X8#,- readWord32OffAddrAsWord32X4#,- readWord64OffAddrAsWord64X2#,- readWord8OffAddrAsWord8X32#,- readWord16OffAddrAsWord16X16#,- readWord32OffAddrAsWord32X8#,- readWord64OffAddrAsWord64X4#,- readWord8OffAddrAsWord8X64#,- readWord16OffAddrAsWord16X32#,- readWord32OffAddrAsWord32X16#,- readWord64OffAddrAsWord64X8#,- readFloatOffAddrAsFloatX4#,- readDoubleOffAddrAsDoubleX2#,- readFloatOffAddrAsFloatX8#,- readDoubleOffAddrAsDoubleX4#,- readFloatOffAddrAsFloatX16#,- readDoubleOffAddrAsDoubleX8#,- writeInt8OffAddrAsInt8X16#,- writeInt16OffAddrAsInt16X8#,- writeInt32OffAddrAsInt32X4#,- writeInt64OffAddrAsInt64X2#,- writeInt8OffAddrAsInt8X32#,- writeInt16OffAddrAsInt16X16#,- writeInt32OffAddrAsInt32X8#,- writeInt64OffAddrAsInt64X4#,- writeInt8OffAddrAsInt8X64#,- writeInt16OffAddrAsInt16X32#,- writeInt32OffAddrAsInt32X16#,- writeInt64OffAddrAsInt64X8#,- writeWord8OffAddrAsWord8X16#,- writeWord16OffAddrAsWord16X8#,- writeWord32OffAddrAsWord32X4#,- writeWord64OffAddrAsWord64X2#,- writeWord8OffAddrAsWord8X32#,- writeWord16OffAddrAsWord16X16#,- writeWord32OffAddrAsWord32X8#,- writeWord64OffAddrAsWord64X4#,- writeWord8OffAddrAsWord8X64#,- writeWord16OffAddrAsWord16X32#,- writeWord32OffAddrAsWord32X16#,- writeWord64OffAddrAsWord64X8#,- writeFloatOffAddrAsFloatX4#,- writeDoubleOffAddrAsDoubleX2#,- writeFloatOffAddrAsFloatX8#,- writeDoubleOffAddrAsDoubleX4#,- writeFloatOffAddrAsFloatX16#,- writeDoubleOffAddrAsDoubleX8#,- --- * Prefetch--- |Prefetch operations: Note how every prefetch operation has a name--- with the pattern prefetch*N#, where N is either 0,1,2, or 3.--- --- This suffix number, N, is the \"locality level\" of the prefetch, following the--- convention in GCC and other compilers.--- Higher locality numbers correspond to the memory being loaded in more--- levels of the cpu cache, and being retained after initial use. The naming--- convention follows the naming convention of the prefetch intrinsic found--- in the GCC and Clang C compilers.--- --- On the LLVM backend, prefetch*N# uses the LLVM prefetch intrinsic--- with locality level N. The code generated by LLVM is target architecture--- dependent, but should agree with the GHC NCG on x86 systems.--- --- On the Sparc and PPC native backends, prefetch*N is a No-Op.--- --- On the x86 NCG, N=0 will generate prefetchNTA,--- N=1 generates prefetcht2, N=2 generates prefetcht1, and--- N=3 generates prefetcht0.--- --- For streaming workloads, the prefetch*0 operations are recommended.--- For workloads which do many reads or writes to a memory location in a short period of time,--- prefetch*3 operations are recommended.--- --- For further reading about prefetch and associated systems performance optimization,--- the instruction set and optimization manuals by Intel and other CPU vendors are--- excellent starting place.--- --- --- The \"Intel 64 and IA-32 Architectures Optimization Reference Manual\" is--- especially a helpful read, even if your software is meant for other CPU--- architectures or vendor hardware. The manual can be found at--- http:\/\/www.intel.com\/content\/www\/us\/en\/architecture-and-technology\/64-ia-32-architectures-optimization-manual.html .--- --- The @prefetchMutableByteArray@ family of operations has the order of operations--- determined by passing around the @State#@ token.--- --- For the @prefetchByteArray@--- and @prefetchAddr@ families of operations, consider the following example:--- --- @let a1 = prefetchByteArray2# a n in ...a1... @--- --- In the above fragement, @a@ is the input variable for the prefetch--- and @a1 == a@ will be true. To ensure that the prefetch is not treated as deadcode,--- the body of the let should only use @a1@ and NOT @a@. The same principle--- applies for uses of prefetch in a loop.--- --- --- prefetchByteArray3#,- prefetchMutableByteArray3#,- prefetchAddr3#,- prefetchByteArray2#,- prefetchMutableByteArray2#,- prefetchAddr2#,- prefetchByteArray1#,- prefetchMutableByteArray1#,- prefetchAddr1#,- prefetchByteArray0#,- prefetchMutableByteArray0#,- prefetchAddr0#,-) where--{--has_side_effects = False-out_of_line = False-can_fail = False-commutable = False-code_size = { primOpCodeSizeDefault }-strictness = { \ arity -> mkClosedStrictSig (replicate arity topDmd) topRes }-fixity = Nothing-llvm_only = False---}--data Char#--gtChar# :: Char# -> Char# -> Int#-gtChar# = let x = x in x--geChar# :: Char# -> Char# -> Int#-geChar# = let x = x in x--eqChar# :: Char# -> Char# -> Int#-eqChar# = let x = x in x--neChar# :: Char# -> Char# -> Int#-neChar# = let x = x in x--ltChar# :: Char# -> Char# -> Int#-ltChar# = let x = x in x--leChar# :: Char# -> Char# -> Int#-leChar# = let x = x in x--ord# :: Char# -> Int#-ord# = let x = x in x--data Int#--infixl 6 +#-(+#) :: Int# -> Int# -> Int#-(+#) = let x = x in x--infixl 6 -#-(-#) :: Int# -> Int# -> Int#-(-#) = let x = x in x---- |Low word of signed integer multiply.--infixl 7 *#-(*#) :: Int# -> Int# -> Int#-(*#) = let x = x in x---- |Return non-zero if there is any possibility that the upper word of a--- signed integer multiply might contain useful information. Return--- zero only if you are completely sure that no overflow can occur.--- On a 32-bit platform, the recommmended implementation is to do a--- 32 x 32 -> 64 signed multiply, and subtract result[63:32] from--- (result[31] >>signed 31). If this is zero, meaning that the--- upper word is merely a sign extension of the lower one, no--- overflow can occur.--- --- On a 64-bit platform it is not always possible to--- acquire the top 64 bits of the result. Therefore, a recommended--- implementation is to take the absolute value of both operands, and--- return 0 iff bits[63:31] of them are zero, since that means that their--- magnitudes fit within 31 bits, so the magnitude of the product must fit--- into 62 bits.--- --- If in doubt, return non-zero, but do make an effort to create the--- correct answer for small args, since otherwise the performance of--- @(*) :: Integer -> Integer -> Integer@ will be poor.--- --mulIntMayOflo# :: Int# -> Int# -> Int#-mulIntMayOflo# = let x = x in x---- |Rounds towards zero.--quotInt# :: Int# -> Int# -> Int#-quotInt# = let x = x in x---- |Satisfies @(quotInt\# x y) *\# y +\# (remInt\# x y) == x@.--remInt# :: Int# -> Int# -> Int#-remInt# = let x = x in x---- |Rounds towards zero.--quotRemInt# :: Int# -> Int# -> (# Int#,Int# #)-quotRemInt# = let x = x in x--andI# :: Int# -> Int# -> Int#-andI# = let x = x in x--orI# :: Int# -> Int# -> Int#-orI# = let x = x in x--xorI# :: Int# -> Int# -> Int#-xorI# = let x = x in x--notI# :: Int# -> Int#-notI# = let x = x in x--negateInt# :: Int# -> Int#-negateInt# = let x = x in x---- |Add with carry. First member of result is (wrapped) sum;--- second member is 0 iff no overflow occured.--addIntC# :: Int# -> Int# -> (# Int#,Int# #)-addIntC# = let x = x in x---- |Subtract with carry. First member of result is (wrapped) difference;--- second member is 0 iff no overflow occured.--subIntC# :: Int# -> Int# -> (# Int#,Int# #)-subIntC# = let x = x in x--infix 4 >#-(>#) :: Int# -> Int# -> Int#-(>#) = let x = x in x--infix 4 >=#-(>=#) :: Int# -> Int# -> Int#-(>=#) = let x = x in x--infix 4 ==#-(==#) :: Int# -> Int# -> Int#-(==#) = let x = x in x--infix 4 /=#-(/=#) :: Int# -> Int# -> Int#-(/=#) = let x = x in x--infix 4 <#-(<#) :: Int# -> Int# -> Int#-(<#) = let x = x in x--infix 4 <=#-(<=#) :: Int# -> Int# -> Int#-(<=#) = let x = x in x--chr# :: Int# -> Char#-chr# = let x = x in x--int2Word# :: Int# -> Word#-int2Word# = let x = x in x--int2Float# :: Int# -> Float#-int2Float# = let x = x in x--int2Double# :: Int# -> Double#-int2Double# = let x = x in x--word2Float# :: Word# -> Float#-word2Float# = let x = x in x--word2Double# :: Word# -> Double#-word2Double# = let x = x in x---- |Shift left. Result undefined if shift amount is not--- in the range 0 to word size - 1 inclusive.--uncheckedIShiftL# :: Int# -> Int# -> Int#-uncheckedIShiftL# = let x = x in x---- |Shift right arithmetic. Result undefined if shift amount is not--- in the range 0 to word size - 1 inclusive.--uncheckedIShiftRA# :: Int# -> Int# -> Int#-uncheckedIShiftRA# = let x = x in x---- |Shift right logical. Result undefined if shift amount is not--- in the range 0 to word size - 1 inclusive.--uncheckedIShiftRL# :: Int# -> Int# -> Int#-uncheckedIShiftRL# = let x = x in x--data Word#--plusWord# :: Word# -> Word# -> Word#-plusWord# = let x = x in x--plusWord2# :: Word# -> Word# -> (# Word#,Word# #)-plusWord2# = let x = x in x--minusWord# :: Word# -> Word# -> Word#-minusWord# = let x = x in x--timesWord# :: Word# -> Word# -> Word#-timesWord# = let x = x in x--timesWord2# :: Word# -> Word# -> (# Word#,Word# #)-timesWord2# = let x = x in x--quotWord# :: Word# -> Word# -> Word#-quotWord# = let x = x in x--remWord# :: Word# -> Word# -> Word#-remWord# = let x = x in x--quotRemWord# :: Word# -> Word# -> (# Word#,Word# #)-quotRemWord# = let x = x in x--quotRemWord2# :: Word# -> Word# -> Word# -> (# Word#,Word# #)-quotRemWord2# = let x = x in x--and# :: Word# -> Word# -> Word#-and# = let x = x in x--or# :: Word# -> Word# -> Word#-or# = let x = x in x--xor# :: Word# -> Word# -> Word#-xor# = let x = x in x--not# :: Word# -> Word#-not# = let x = x in x---- |Shift left logical. Result undefined if shift amount is not--- in the range 0 to word size - 1 inclusive.--uncheckedShiftL# :: Word# -> Int# -> Word#-uncheckedShiftL# = let x = x in x---- |Shift right logical. Result undefined if shift amount is not--- in the range 0 to word size - 1 inclusive.--uncheckedShiftRL# :: Word# -> Int# -> Word#-uncheckedShiftRL# = let x = x in x--word2Int# :: Word# -> Int#-word2Int# = let x = x in x--gtWord# :: Word# -> Word# -> Int#-gtWord# = let x = x in x--geWord# :: Word# -> Word# -> Int#-geWord# = let x = x in x--eqWord# :: Word# -> Word# -> Int#-eqWord# = let x = x in x--neWord# :: Word# -> Word# -> Int#-neWord# = let x = x in x--ltWord# :: Word# -> Word# -> Int#-ltWord# = let x = x in x--leWord# :: Word# -> Word# -> Int#-leWord# = let x = x in x---- |Count the number of set bits in the lower 8 bits of a word.--popCnt8# :: Word# -> Word#-popCnt8# = let x = x in x---- |Count the number of set bits in the lower 16 bits of a word.--popCnt16# :: Word# -> Word#-popCnt16# = let x = x in x---- |Count the number of set bits in the lower 32 bits of a word.--popCnt32# :: Word# -> Word#-popCnt32# = let x = x in x---- |Count the number of set bits in a 64-bit word.--popCnt64# :: Word# -> Word#-popCnt64# = let x = x in x---- |Count the number of set bits in a word.--popCnt# :: Word# -> Word#-popCnt# = let x = x in x---- |Swap bytes in the lower 16 bits of a word. The higher bytes are undefined. --byteSwap16# :: Word# -> Word#-byteSwap16# = let x = x in x---- |Swap bytes in the lower 32 bits of a word. The higher bytes are undefined. --byteSwap32# :: Word# -> Word#-byteSwap32# = let x = x in x---- |Swap bytes in a 64 bits of a word.--byteSwap64# :: Word# -> Word#-byteSwap64# = let x = x in x---- |Swap bytes in a word.--byteSwap# :: Word# -> Word#-byteSwap# = let x = x in x--narrow8Int# :: Int# -> Int#-narrow8Int# = let x = x in x--narrow16Int# :: Int# -> Int#-narrow16Int# = let x = x in x--narrow32Int# :: Int# -> Int#-narrow32Int# = let x = x in x--narrow8Word# :: Word# -> Word#-narrow8Word# = let x = x in x--narrow16Word# :: Word# -> Word#-narrow16Word# = let x = x in x--narrow32Word# :: Word# -> Word#-narrow32Word# = let x = x in x--data Double#--infix 4 >##-(>##) :: Double# -> Double# -> Int#-(>##) = let x = x in x--infix 4 >=##-(>=##) :: Double# -> Double# -> Int#-(>=##) = let x = x in x--infix 4 ==##-(==##) :: Double# -> Double# -> Int#-(==##) = let x = x in x--infix 4 /=##-(/=##) :: Double# -> Double# -> Int#-(/=##) = let x = x in x--infix 4 <##-(<##) :: Double# -> Double# -> Int#-(<##) = let x = x in x--infix 4 <=##-(<=##) :: Double# -> Double# -> Int#-(<=##) = let x = x in x--infixl 6 +##-(+##) :: Double# -> Double# -> Double#-(+##) = let x = x in x--infixl 6 -##-(-##) :: Double# -> Double# -> Double#-(-##) = let x = x in x--infixl 7 *##-(*##) :: Double# -> Double# -> Double#-(*##) = let x = x in x--infixl 7 /##-(/##) :: Double# -> Double# -> Double#-(/##) = let x = x in x--negateDouble# :: Double# -> Double#-negateDouble# = let x = x in x---- |Truncates a @Double#@ value to the nearest @Int#@.--- Results are undefined if the truncation if truncation yields--- a value outside the range of @Int#@.--double2Int# :: Double# -> Int#-double2Int# = let x = x in x--double2Float# :: Double# -> Float#-double2Float# = let x = x in x--expDouble# :: Double# -> Double#-expDouble# = let x = x in x--logDouble# :: Double# -> Double#-logDouble# = let x = x in x--sqrtDouble# :: Double# -> Double#-sqrtDouble# = let x = x in x--sinDouble# :: Double# -> Double#-sinDouble# = let x = x in x--cosDouble# :: Double# -> Double#-cosDouble# = let x = x in x--tanDouble# :: Double# -> Double#-tanDouble# = let x = x in x--asinDouble# :: Double# -> Double#-asinDouble# = let x = x in x--acosDouble# :: Double# -> Double#-acosDouble# = let x = x in x--atanDouble# :: Double# -> Double#-atanDouble# = let x = x in x--sinhDouble# :: Double# -> Double#-sinhDouble# = let x = x in x--coshDouble# :: Double# -> Double#-coshDouble# = let x = x in x--tanhDouble# :: Double# -> Double#-tanhDouble# = let x = x in x---- |Exponentiation.--(**##) :: Double# -> Double# -> Double#-(**##) = let x = x in x---- |Convert to integer.--- First component of the result is -1 or 1, indicating the sign of the--- mantissa. The next two are the high and low 32 bits of the mantissa--- respectively, and the last is the exponent.--decodeDouble_2Int# :: Double# -> (# Int#,Word#,Word#,Int# #)-decodeDouble_2Int# = let x = x in x--data Float#--gtFloat# :: Float# -> Float# -> Int#-gtFloat# = let x = x in x--geFloat# :: Float# -> Float# -> Int#-geFloat# = let x = x in x--eqFloat# :: Float# -> Float# -> Int#-eqFloat# = let x = x in x--neFloat# :: Float# -> Float# -> Int#-neFloat# = let x = x in x--ltFloat# :: Float# -> Float# -> Int#-ltFloat# = let x = x in x--leFloat# :: Float# -> Float# -> Int#-leFloat# = let x = x in x--plusFloat# :: Float# -> Float# -> Float#-plusFloat# = let x = x in x--minusFloat# :: Float# -> Float# -> Float#-minusFloat# = let x = x in x--timesFloat# :: Float# -> Float# -> Float#-timesFloat# = let x = x in x--divideFloat# :: Float# -> Float# -> Float#-divideFloat# = let x = x in x--negateFloat# :: Float# -> Float#-negateFloat# = let x = x in x---- |Truncates a @Float#@ value to the nearest @Int#@.--- Results are undefined if the truncation if truncation yields--- a value outside the range of @Int#@.--float2Int# :: Float# -> Int#-float2Int# = let x = x in x--expFloat# :: Float# -> Float#-expFloat# = let x = x in x--logFloat# :: Float# -> Float#-logFloat# = let x = x in x--sqrtFloat# :: Float# -> Float#-sqrtFloat# = let x = x in x--sinFloat# :: Float# -> Float#-sinFloat# = let x = x in x--cosFloat# :: Float# -> Float#-cosFloat# = let x = x in x--tanFloat# :: Float# -> Float#-tanFloat# = let x = x in x--asinFloat# :: Float# -> Float#-asinFloat# = let x = x in x--acosFloat# :: Float# -> Float#-acosFloat# = let x = x in x--atanFloat# :: Float# -> Float#-atanFloat# = let x = x in x--sinhFloat# :: Float# -> Float#-sinhFloat# = let x = x in x--coshFloat# :: Float# -> Float#-coshFloat# = let x = x in x--tanhFloat# :: Float# -> Float#-tanhFloat# = let x = x in x--powerFloat# :: Float# -> Float# -> Float#-powerFloat# = let x = x in x--float2Double# :: Float# -> Double#-float2Double# = let x = x in x---- |Convert to integers.--- First @Int\#@ in result is the mantissa; second is the exponent.--decodeFloat_Int# :: Float# -> (# Int#,Int# #)-decodeFloat_Int# = let x = x in x--data Array# a--data MutableArray# s a---- |Create a new mutable array with the specified number of elements,--- in the specified state thread,--- with each element containing the specified initial value.--newArray# :: Int# -> a -> State# s -> (# State# s,MutableArray# s a #)-newArray# = let x = x in x--sameMutableArray# :: MutableArray# s a -> MutableArray# s a -> Int#-sameMutableArray# = let x = x in x---- |Read from specified index of mutable array. Result is not yet evaluated.--readArray# :: MutableArray# s a -> Int# -> State# s -> (# State# s,a #)-readArray# = let x = x in x---- |Write to specified index of mutable array.--writeArray# :: MutableArray# s a -> Int# -> a -> State# s -> State# s-writeArray# = let x = x in x---- |Return the number of elements in the array.--sizeofArray# :: Array# a -> Int#-sizeofArray# = let x = x in x---- |Return the number of elements in the array.--sizeofMutableArray# :: MutableArray# s a -> Int#-sizeofMutableArray# = let x = x in x---- |Read from specified index of immutable array. Result is packaged into--- an unboxed singleton; the result itself is not yet evaluated.--indexArray# :: Array# a -> Int# -> (# a #)-indexArray# = let x = x in x---- |Make a mutable array immutable, without copying.--unsafeFreezeArray# :: MutableArray# s a -> State# s -> (# State# s,Array# a #)-unsafeFreezeArray# = let x = x in x---- |Make an immutable array mutable, without copying.--unsafeThawArray# :: Array# a -> State# s -> (# State# s,MutableArray# s a #)-unsafeThawArray# = let x = x in x---- |Copy a range of the Array# to the specified region in the MutableArray#.--- Both arrays must fully contain the specified ranges, but this is not checked.--- The two arrays must not be the same array in different states, but this is not checked either.--copyArray# :: Array# a -> Int# -> MutableArray# s a -> Int# -> Int# -> State# s -> State# s-copyArray# = let x = x in x---- |Copy a range of the first MutableArray# to the specified region in the second MutableArray#.--- Both arrays must fully contain the specified ranges, but this is not checked.--copyMutableArray# :: MutableArray# s a -> Int# -> MutableArray# s a -> Int# -> Int# -> State# s -> State# s-copyMutableArray# = let x = x in x---- |Return a newly allocated Array# with the specified subrange of the provided Array#.--- The provided Array# should contain the full subrange specified by the two Int#s, but this is not checked.--cloneArray# :: Array# a -> Int# -> Int# -> Array# a-cloneArray# = let x = x in x---- |Return a newly allocated Array# with the specified subrange of the provided Array#.--- The provided MutableArray# should contain the full subrange specified by the two Int#s, but this is not checked.--cloneMutableArray# :: MutableArray# s a -> Int# -> Int# -> State# s -> (# State# s,MutableArray# s a #)-cloneMutableArray# = let x = x in x---- |Return a newly allocated Array# with the specified subrange of the provided MutableArray#.--- The provided MutableArray# should contain the full subrange specified by the two Int#s, but this is not checked.--freezeArray# :: MutableArray# s a -> Int# -> Int# -> State# s -> (# State# s,Array# a #)-freezeArray# = let x = x in x---- |Return a newly allocated Array# with the specified subrange of the provided MutableArray#.--- The provided Array# should contain the full subrange specified by the two Int#s, but this is not checked.--thawArray# :: Array# a -> Int# -> Int# -> State# s -> (# State# s,MutableArray# s a #)-thawArray# = let x = x in x---- |Unsafe, machine-level atomic compare and swap on an element within an Array.--casArray# :: MutableArray# s a -> Int# -> a -> a -> State# s -> (# State# s,Int#,a #)-casArray# = let x = x in x--data ByteArray#--data MutableByteArray# s---- |Create a new mutable byte array of specified size (in bytes), in--- the specified state thread.--newByteArray# :: Int# -> State# s -> (# State# s,MutableByteArray# s #)-newByteArray# = let x = x in x---- |Create a mutable byte array that the GC guarantees not to move.--newPinnedByteArray# :: Int# -> State# s -> (# State# s,MutableByteArray# s #)-newPinnedByteArray# = let x = x in x---- |Create a mutable byte array, aligned by the specified amount, that the GC guarantees not to move.--newAlignedPinnedByteArray# :: Int# -> Int# -> State# s -> (# State# s,MutableByteArray# s #)-newAlignedPinnedByteArray# = let x = x in x---- |Intended for use with pinned arrays; otherwise very unsafe!--byteArrayContents# :: ByteArray# -> Addr#-byteArrayContents# = let x = x in x--sameMutableByteArray# :: MutableByteArray# s -> MutableByteArray# s -> Int#-sameMutableByteArray# = let x = x in x---- |Make a mutable byte array immutable, without copying.--unsafeFreezeByteArray# :: MutableByteArray# s -> State# s -> (# State# s,ByteArray# #)-unsafeFreezeByteArray# = let x = x in x---- |Return the size of the array in bytes.--sizeofByteArray# :: ByteArray# -> Int#-sizeofByteArray# = let x = x in x---- |Return the size of the array in bytes.--sizeofMutableByteArray# :: MutableByteArray# s -> Int#-sizeofMutableByteArray# = let x = x in x---- |Read 8-bit character; offset in bytes.--indexCharArray# :: ByteArray# -> Int# -> Char#-indexCharArray# = let x = x in x---- |Read 31-bit character; offset in 4-byte words.--indexWideCharArray# :: ByteArray# -> Int# -> Char#-indexWideCharArray# = let x = x in x--indexIntArray# :: ByteArray# -> Int# -> Int#-indexIntArray# = let x = x in x--indexWordArray# :: ByteArray# -> Int# -> Word#-indexWordArray# = let x = x in x--indexAddrArray# :: ByteArray# -> Int# -> Addr#-indexAddrArray# = let x = x in x--indexFloatArray# :: ByteArray# -> Int# -> Float#-indexFloatArray# = let x = x in x--indexDoubleArray# :: ByteArray# -> Int# -> Double#-indexDoubleArray# = let x = x in x--indexStablePtrArray# :: ByteArray# -> Int# -> StablePtr# a-indexStablePtrArray# = let x = x in x--indexInt8Array# :: ByteArray# -> Int# -> Int#-indexInt8Array# = let x = x in x--indexInt16Array# :: ByteArray# -> Int# -> Int#-indexInt16Array# = let x = x in x--indexInt32Array# :: ByteArray# -> Int# -> Int#-indexInt32Array# = let x = x in x--indexInt64Array# :: ByteArray# -> Int# -> Int#-indexInt64Array# = let x = x in x--indexWord8Array# :: ByteArray# -> Int# -> Word#-indexWord8Array# = let x = x in x--indexWord16Array# :: ByteArray# -> Int# -> Word#-indexWord16Array# = let x = x in x--indexWord32Array# :: ByteArray# -> Int# -> Word#-indexWord32Array# = let x = x in x--indexWord64Array# :: ByteArray# -> Int# -> Word#-indexWord64Array# = let x = x in x---- |Read 8-bit character; offset in bytes.--readCharArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Char# #)-readCharArray# = let x = x in x---- |Read 31-bit character; offset in 4-byte words.--readWideCharArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Char# #)-readWideCharArray# = let x = x in x--readIntArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int# #)-readIntArray# = let x = x in x--readWordArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word# #)-readWordArray# = let x = x in x--readAddrArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Addr# #)-readAddrArray# = let x = x in x--readFloatArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Float# #)-readFloatArray# = let x = x in x--readDoubleArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Double# #)-readDoubleArray# = let x = x in x--readStablePtrArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,StablePtr# a #)-readStablePtrArray# = let x = x in x--readInt8Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int# #)-readInt8Array# = let x = x in x--readInt16Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int# #)-readInt16Array# = let x = x in x--readInt32Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int# #)-readInt32Array# = let x = x in x--readInt64Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int# #)-readInt64Array# = let x = x in x--readWord8Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word# #)-readWord8Array# = let x = x in x--readWord16Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word# #)-readWord16Array# = let x = x in x--readWord32Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word# #)-readWord32Array# = let x = x in x--readWord64Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word# #)-readWord64Array# = let x = x in x---- |Write 8-bit character; offset in bytes.--writeCharArray# :: MutableByteArray# s -> Int# -> Char# -> State# s -> State# s-writeCharArray# = let x = x in x---- |Write 31-bit character; offset in 4-byte words.--writeWideCharArray# :: MutableByteArray# s -> Int# -> Char# -> State# s -> State# s-writeWideCharArray# = let x = x in x--writeIntArray# :: MutableByteArray# s -> Int# -> Int# -> State# s -> State# s-writeIntArray# = let x = x in x--writeWordArray# :: MutableByteArray# s -> Int# -> Word# -> State# s -> State# s-writeWordArray# = let x = x in x--writeAddrArray# :: MutableByteArray# s -> Int# -> Addr# -> State# s -> State# s-writeAddrArray# = let x = x in x--writeFloatArray# :: MutableByteArray# s -> Int# -> Float# -> State# s -> State# s-writeFloatArray# = let x = x in x--writeDoubleArray# :: MutableByteArray# s -> Int# -> Double# -> State# s -> State# s-writeDoubleArray# = let x = x in x--writeStablePtrArray# :: MutableByteArray# s -> Int# -> StablePtr# a -> State# s -> State# s-writeStablePtrArray# = let x = x in x--writeInt8Array# :: MutableByteArray# s -> Int# -> Int# -> State# s -> State# s-writeInt8Array# = let x = x in x--writeInt16Array# :: MutableByteArray# s -> Int# -> Int# -> State# s -> State# s-writeInt16Array# = let x = x in x--writeInt32Array# :: MutableByteArray# s -> Int# -> Int# -> State# s -> State# s-writeInt32Array# = let x = x in x--writeInt64Array# :: MutableByteArray# s -> Int# -> Int# -> State# s -> State# s-writeInt64Array# = let x = x in x--writeWord8Array# :: MutableByteArray# s -> Int# -> Word# -> State# s -> State# s-writeWord8Array# = let x = x in x--writeWord16Array# :: MutableByteArray# s -> Int# -> Word# -> State# s -> State# s-writeWord16Array# = let x = x in x--writeWord32Array# :: MutableByteArray# s -> Int# -> Word# -> State# s -> State# s-writeWord32Array# = let x = x in x--writeWord64Array# :: MutableByteArray# s -> Int# -> Word# -> State# s -> State# s-writeWord64Array# = let x = x in x---- |Copy a range of the ByteArray# to the specified region in the MutableByteArray#.--- Both arrays must fully contain the specified ranges, but this is not checked.--- The two arrays must not be the same array in different states, but this is not checked either.--copyByteArray# :: ByteArray# -> Int# -> MutableByteArray# s -> Int# -> Int# -> State# s -> State# s-copyByteArray# = let x = x in x---- |Copy a range of the first MutableByteArray# to the specified region in the second MutableByteArray#.--- Both arrays must fully contain the specified ranges, but this is not checked.--copyMutableByteArray# :: MutableByteArray# s -> Int# -> MutableByteArray# s -> Int# -> Int# -> State# s -> State# s-copyMutableByteArray# = let x = x in x---- |Copy a range of the ByteArray# to the memory range starting at the Addr#.--- The ByteArray# and the memory region at Addr# must fully contain the--- specified ranges, but this is not checked. The Addr# must not point into the--- ByteArray# (e.g. if the ByteArray# were pinned), but this is not checked--- either.--copyByteArrayToAddr# :: ByteArray# -> Int# -> Addr# -> Int# -> State# s -> State# s-copyByteArrayToAddr# = let x = x in x---- |Copy a range of the MutableByteArray# to the memory range starting at the--- Addr#. The MutableByteArray# and the memory region at Addr# must fully--- contain the specified ranges, but this is not checked. The Addr# must not--- point into the MutableByteArray# (e.g. if the MutableByteArray# were--- pinned), but this is not checked either.--copyMutableByteArrayToAddr# :: MutableByteArray# s -> Int# -> Addr# -> Int# -> State# s -> State# s-copyMutableByteArrayToAddr# = let x = x in x---- |Copy a memory range starting at the Addr# to the specified range in the--- MutableByteArray#. The memory region at Addr# and the ByteArray# must fully--- contain the specified ranges, but this is not checked. The Addr# must not--- point into the MutableByteArray# (e.g. if the MutableByteArray# were pinned),--- but this is not checked either.--copyAddrToByteArray# :: Addr# -> MutableByteArray# s -> Int# -> Int# -> State# s -> State# s-copyAddrToByteArray# = let x = x in x---- |Set the range of the MutableByteArray# to the specified character.--setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Int# -> State# s -> State# s-setByteArray# = let x = x in x---- |Machine-level atomic compare and swap on a word within a ByteArray.--casIntArray# :: MutableByteArray# s -> Int# -> Int# -> Int# -> State# s -> (# State# s,Int# #)-casIntArray# = let x = x in x---- |Machine-level word-sized fetch-and-add within a ByteArray.--fetchAddIntArray# :: MutableByteArray# s -> Int# -> Int# -> State# s -> (# State# s,Int# #)-fetchAddIntArray# = let x = x in x--data ArrayArray#--data MutableArrayArray# s---- |Create a new mutable array of arrays with the specified number of elements,--- in the specified state thread, with each element recursively referring to the--- newly created array.--newArrayArray# :: Int# -> State# s -> (# State# s,MutableArrayArray# s #)-newArrayArray# = let x = x in x--sameMutableArrayArray# :: MutableArrayArray# s -> MutableArrayArray# s -> Int#-sameMutableArrayArray# = let x = x in x---- |Make a mutable array of arrays immutable, without copying.--unsafeFreezeArrayArray# :: MutableArrayArray# s -> State# s -> (# State# s,ArrayArray# #)-unsafeFreezeArrayArray# = let x = x in x---- |Return the number of elements in the array.--sizeofArrayArray# :: ArrayArray# -> Int#-sizeofArrayArray# = let x = x in x---- |Return the number of elements in the array.--sizeofMutableArrayArray# :: MutableArrayArray# s -> Int#-sizeofMutableArrayArray# = let x = x in x--indexByteArrayArray# :: ArrayArray# -> Int# -> ByteArray#-indexByteArrayArray# = let x = x in x--indexArrayArrayArray# :: ArrayArray# -> Int# -> ArrayArray#-indexArrayArrayArray# = let x = x in x--readByteArrayArray# :: MutableArrayArray# s -> Int# -> State# s -> (# State# s,ByteArray# #)-readByteArrayArray# = let x = x in x--readMutableByteArrayArray# :: MutableArrayArray# s -> Int# -> State# s -> (# State# s,MutableByteArray# s #)-readMutableByteArrayArray# = let x = x in x--readArrayArrayArray# :: MutableArrayArray# s -> Int# -> State# s -> (# State# s,ArrayArray# #)-readArrayArrayArray# = let x = x in x--readMutableArrayArrayArray# :: MutableArrayArray# s -> Int# -> State# s -> (# State# s,MutableArrayArray# s #)-readMutableArrayArrayArray# = let x = x in x--writeByteArrayArray# :: MutableArrayArray# s -> Int# -> ByteArray# -> State# s -> State# s-writeByteArrayArray# = let x = x in x--writeMutableByteArrayArray# :: MutableArrayArray# s -> Int# -> MutableByteArray# s -> State# s -> State# s-writeMutableByteArrayArray# = let x = x in x--writeArrayArrayArray# :: MutableArrayArray# s -> Int# -> ArrayArray# -> State# s -> State# s-writeArrayArrayArray# = let x = x in x--writeMutableArrayArrayArray# :: MutableArrayArray# s -> Int# -> MutableArrayArray# s -> State# s -> State# s-writeMutableArrayArrayArray# = let x = x in x---- |Copy a range of the ArrayArray# to the specified region in the MutableArrayArray#.--- Both arrays must fully contain the specified ranges, but this is not checked.--- The two arrays must not be the same array in different states, but this is not checked either.--copyArrayArray# :: ArrayArray# -> Int# -> MutableArrayArray# s -> Int# -> Int# -> State# s -> State# s-copyArrayArray# = let x = x in x---- |Copy a range of the first MutableArrayArray# to the specified region in the second--- MutableArrayArray#.--- Both arrays must fully contain the specified ranges, but this is not checked.--copyMutableArrayArray# :: MutableArrayArray# s -> Int# -> MutableArrayArray# s -> Int# -> Int# -> State# s -> State# s-copyMutableArrayArray# = let x = x in x---- | An arbitrary machine address assumed to point outside--- the garbage-collected heap. --data Addr#---- | The null address. --nullAddr# :: Addr#-nullAddr# = let x = x in x--plusAddr# :: Addr# -> Int# -> Addr#-plusAddr# = let x = x in x---- |Result is meaningless if two @Addr\#@s are so far apart that their--- difference doesn\'t fit in an @Int\#@.--minusAddr# :: Addr# -> Addr# -> Int#-minusAddr# = let x = x in x---- |Return the remainder when the @Addr\#@ arg, treated like an @Int\#@,--- is divided by the @Int\#@ arg.--remAddr# :: Addr# -> Int# -> Int#-remAddr# = let x = x in x---- |Coerce directly from address to int. Strongly deprecated.--addr2Int# :: Addr# -> Int#-addr2Int# = let x = x in x---- |Coerce directly from int to address. Strongly deprecated.--int2Addr# :: Int# -> Addr#-int2Addr# = let x = x in x--gtAddr# :: Addr# -> Addr# -> Int#-gtAddr# = let x = x in x--geAddr# :: Addr# -> Addr# -> Int#-geAddr# = let x = x in x--eqAddr# :: Addr# -> Addr# -> Int#-eqAddr# = let x = x in x--neAddr# :: Addr# -> Addr# -> Int#-neAddr# = let x = x in x--ltAddr# :: Addr# -> Addr# -> Int#-ltAddr# = let x = x in x--leAddr# :: Addr# -> Addr# -> Int#-leAddr# = let x = x in x---- |Reads 8-bit character; offset in bytes.--indexCharOffAddr# :: Addr# -> Int# -> Char#-indexCharOffAddr# = let x = x in x---- |Reads 31-bit character; offset in 4-byte words.--indexWideCharOffAddr# :: Addr# -> Int# -> Char#-indexWideCharOffAddr# = let x = x in x--indexIntOffAddr# :: Addr# -> Int# -> Int#-indexIntOffAddr# = let x = x in x--indexWordOffAddr# :: Addr# -> Int# -> Word#-indexWordOffAddr# = let x = x in x--indexAddrOffAddr# :: Addr# -> Int# -> Addr#-indexAddrOffAddr# = let x = x in x--indexFloatOffAddr# :: Addr# -> Int# -> Float#-indexFloatOffAddr# = let x = x in x--indexDoubleOffAddr# :: Addr# -> Int# -> Double#-indexDoubleOffAddr# = let x = x in x--indexStablePtrOffAddr# :: Addr# -> Int# -> StablePtr# a-indexStablePtrOffAddr# = let x = x in x--indexInt8OffAddr# :: Addr# -> Int# -> Int#-indexInt8OffAddr# = let x = x in x--indexInt16OffAddr# :: Addr# -> Int# -> Int#-indexInt16OffAddr# = let x = x in x--indexInt32OffAddr# :: Addr# -> Int# -> Int#-indexInt32OffAddr# = let x = x in x--indexInt64OffAddr# :: Addr# -> Int# -> Int#-indexInt64OffAddr# = let x = x in x--indexWord8OffAddr# :: Addr# -> Int# -> Word#-indexWord8OffAddr# = let x = x in x--indexWord16OffAddr# :: Addr# -> Int# -> Word#-indexWord16OffAddr# = let x = x in x--indexWord32OffAddr# :: Addr# -> Int# -> Word#-indexWord32OffAddr# = let x = x in x--indexWord64OffAddr# :: Addr# -> Int# -> Word#-indexWord64OffAddr# = let x = x in x---- |Reads 8-bit character; offset in bytes.--readCharOffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Char# #)-readCharOffAddr# = let x = x in x---- |Reads 31-bit character; offset in 4-byte words.--readWideCharOffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Char# #)-readWideCharOffAddr# = let x = x in x--readIntOffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int# #)-readIntOffAddr# = let x = x in x--readWordOffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word# #)-readWordOffAddr# = let x = x in x--readAddrOffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Addr# #)-readAddrOffAddr# = let x = x in x--readFloatOffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Float# #)-readFloatOffAddr# = let x = x in x--readDoubleOffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Double# #)-readDoubleOffAddr# = let x = x in x--readStablePtrOffAddr# :: Addr# -> Int# -> State# s -> (# State# s,StablePtr# a #)-readStablePtrOffAddr# = let x = x in x--readInt8OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int# #)-readInt8OffAddr# = let x = x in x--readInt16OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int# #)-readInt16OffAddr# = let x = x in x--readInt32OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int# #)-readInt32OffAddr# = let x = x in x--readInt64OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int# #)-readInt64OffAddr# = let x = x in x--readWord8OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word# #)-readWord8OffAddr# = let x = x in x--readWord16OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word# #)-readWord16OffAddr# = let x = x in x--readWord32OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word# #)-readWord32OffAddr# = let x = x in x--readWord64OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word# #)-readWord64OffAddr# = let x = x in x--writeCharOffAddr# :: Addr# -> Int# -> Char# -> State# s -> State# s-writeCharOffAddr# = let x = x in x--writeWideCharOffAddr# :: Addr# -> Int# -> Char# -> State# s -> State# s-writeWideCharOffAddr# = let x = x in x--writeIntOffAddr# :: Addr# -> Int# -> Int# -> State# s -> State# s-writeIntOffAddr# = let x = x in x--writeWordOffAddr# :: Addr# -> Int# -> Word# -> State# s -> State# s-writeWordOffAddr# = let x = x in x--writeAddrOffAddr# :: Addr# -> Int# -> Addr# -> State# s -> State# s-writeAddrOffAddr# = let x = x in x--writeFloatOffAddr# :: Addr# -> Int# -> Float# -> State# s -> State# s-writeFloatOffAddr# = let x = x in x--writeDoubleOffAddr# :: Addr# -> Int# -> Double# -> State# s -> State# s-writeDoubleOffAddr# = let x = x in x--writeStablePtrOffAddr# :: Addr# -> Int# -> StablePtr# a -> State# s -> State# s-writeStablePtrOffAddr# = let x = x in x--writeInt8OffAddr# :: Addr# -> Int# -> Int# -> State# s -> State# s-writeInt8OffAddr# = let x = x in x--writeInt16OffAddr# :: Addr# -> Int# -> Int# -> State# s -> State# s-writeInt16OffAddr# = let x = x in x--writeInt32OffAddr# :: Addr# -> Int# -> Int# -> State# s -> State# s-writeInt32OffAddr# = let x = x in x--writeInt64OffAddr# :: Addr# -> Int# -> Int# -> State# s -> State# s-writeInt64OffAddr# = let x = x in x--writeWord8OffAddr# :: Addr# -> Int# -> Word# -> State# s -> State# s-writeWord8OffAddr# = let x = x in x--writeWord16OffAddr# :: Addr# -> Int# -> Word# -> State# s -> State# s-writeWord16OffAddr# = let x = x in x--writeWord32OffAddr# :: Addr# -> Int# -> Word# -> State# s -> State# s-writeWord32OffAddr# = let x = x in x--writeWord64OffAddr# :: Addr# -> Int# -> Word# -> State# s -> State# s-writeWord64OffAddr# = let x = x in x---- |A @MutVar\#@ behaves like a single-element mutable array.--data MutVar# s a---- |Create @MutVar\#@ with specified initial value in specified state thread.--newMutVar# :: a -> State# s -> (# State# s,MutVar# s a #)-newMutVar# = let x = x in x---- |Read contents of @MutVar\#@. Result is not yet evaluated.--readMutVar# :: MutVar# s a -> State# s -> (# State# s,a #)-readMutVar# = let x = x in x---- |Write contents of @MutVar\#@.--writeMutVar# :: MutVar# s a -> a -> State# s -> State# s-writeMutVar# = let x = x in x--sameMutVar# :: MutVar# s a -> MutVar# s a -> Int#-sameMutVar# = let x = x in x--atomicModifyMutVar# :: MutVar# s a -> (a -> b) -> State# s -> (# State# s,c #)-atomicModifyMutVar# = let x = x in x--casMutVar# :: MutVar# s a -> a -> a -> State# s -> (# State# s,Int#,a #)-casMutVar# = let x = x in x--catch# :: (State# (RealWorld) -> (# State# (RealWorld),a #)) -> (b -> State# (RealWorld) -> (# State# (RealWorld),a #)) -> State# (RealWorld) -> (# State# (RealWorld),a #)-catch# = let x = x in x--raise# :: a -> b-raise# = let x = x in x--raiseIO# :: a -> State# (RealWorld) -> (# State# (RealWorld),b #)-raiseIO# = let x = x in x--maskAsyncExceptions# :: (State# (RealWorld) -> (# State# (RealWorld),a #)) -> State# (RealWorld) -> (# State# (RealWorld),a #)-maskAsyncExceptions# = let x = x in x--maskUninterruptible# :: (State# (RealWorld) -> (# State# (RealWorld),a #)) -> State# (RealWorld) -> (# State# (RealWorld),a #)-maskUninterruptible# = let x = x in x--unmaskAsyncExceptions# :: (State# (RealWorld) -> (# State# (RealWorld),a #)) -> State# (RealWorld) -> (# State# (RealWorld),a #)-unmaskAsyncExceptions# = let x = x in x--getMaskingState# :: State# (RealWorld) -> (# State# (RealWorld),Int# #)-getMaskingState# = let x = x in x--data TVar# s a--atomically# :: (State# (RealWorld) -> (# State# (RealWorld),a #)) -> State# (RealWorld) -> (# State# (RealWorld),a #)-atomically# = let x = x in x--retry# :: State# (RealWorld) -> (# State# (RealWorld),a #)-retry# = let x = x in x--catchRetry# :: (State# (RealWorld) -> (# State# (RealWorld),a #)) -> (State# (RealWorld) -> (# State# (RealWorld),a #)) -> State# (RealWorld) -> (# State# (RealWorld),a #)-catchRetry# = let x = x in x--catchSTM# :: (State# (RealWorld) -> (# State# (RealWorld),a #)) -> (b -> State# (RealWorld) -> (# State# (RealWorld),a #)) -> State# (RealWorld) -> (# State# (RealWorld),a #)-catchSTM# = let x = x in x--check# :: (State# (RealWorld) -> (# State# (RealWorld),a #)) -> State# (RealWorld) -> (# State# (RealWorld),() #)-check# = let x = x in x---- |Create a new @TVar\#@ holding a specified initial value.--newTVar# :: a -> State# s -> (# State# s,TVar# s a #)-newTVar# = let x = x in x---- |Read contents of @TVar\#@. Result is not yet evaluated.--readTVar# :: TVar# s a -> State# s -> (# State# s,a #)-readTVar# = let x = x in x---- |Read contents of @TVar\#@ outside an STM transaction--readTVarIO# :: TVar# s a -> State# s -> (# State# s,a #)-readTVarIO# = let x = x in x---- |Write contents of @TVar\#@.--writeTVar# :: TVar# s a -> a -> State# s -> State# s-writeTVar# = let x = x in x--sameTVar# :: TVar# s a -> TVar# s a -> Int#-sameTVar# = let x = x in x---- | A shared mutable variable (/not/ the same as a @MutVar\#@!).--- (Note: in a non-concurrent implementation, @(MVar\# a)@ can be--- represented by @(MutVar\# (Maybe a))@.) --data MVar# s a---- |Create new @MVar\#@; initially empty.--newMVar# :: State# s -> (# State# s,MVar# s a #)-newMVar# = let x = x in x---- |If @MVar\#@ is empty, block until it becomes full.--- Then remove and return its contents, and set it empty.--takeMVar# :: MVar# s a -> State# s -> (# State# s,a #)-takeMVar# = let x = x in x---- |If @MVar\#@ is empty, immediately return with integer 0 and value undefined.--- Otherwise, return with integer 1 and contents of @MVar\#@, and set @MVar\#@ empty.--tryTakeMVar# :: MVar# s a -> State# s -> (# State# s,Int#,a #)-tryTakeMVar# = let x = x in x---- |If @MVar\#@ is full, block until it becomes empty.--- Then store value arg as its new contents.--putMVar# :: MVar# s a -> a -> State# s -> State# s-putMVar# = let x = x in x---- |If @MVar\#@ is full, immediately return with integer 0.--- Otherwise, store value arg as @MVar\#@\'s new contents, and return with integer 1.--tryPutMVar# :: MVar# s a -> a -> State# s -> (# State# s,Int# #)-tryPutMVar# = let x = x in x---- |If @MVar\#@ is empty, block until it becomes full.--- Then read its contents without modifying the MVar, without possibility--- of intervention from other threads.--readMVar# :: MVar# s a -> State# s -> (# State# s,a #)-readMVar# = let x = x in x---- |If @MVar\#@ is empty, immediately return with integer 0 and value undefined.--- Otherwise, return with integer 1 and contents of @MVar\#@.--tryReadMVar# :: MVar# s a -> State# s -> (# State# s,Int#,a #)-tryReadMVar# = let x = x in x--sameMVar# :: MVar# s a -> MVar# s a -> Int#-sameMVar# = let x = x in x---- |Return 1 if @MVar\#@ is empty; 0 otherwise.--isEmptyMVar# :: MVar# s a -> State# s -> (# State# s,Int# #)-isEmptyMVar# = let x = x in x---- |Sleep specified number of microseconds.--delay# :: Int# -> State# s -> State# s-delay# = let x = x in x---- |Block until input is available on specified file descriptor.--waitRead# :: Int# -> State# s -> State# s-waitRead# = let x = x in x---- |Block until output is possible on specified file descriptor.--waitWrite# :: Int# -> State# s -> State# s-waitWrite# = let x = x in x---- | @State\#@ is the primitive, unlifted type of states. It has--- one type parameter, thus @State\# RealWorld@, or @State\# s@,--- where s is a type variable. The only purpose of the type parameter--- is to keep different state threads separate. It is represented by--- nothing at all. --data State# s---- | @RealWorld@ is deeply magical. It is /primitive/, but it is not--- /unlifted/ (hence @ptrArg@). We never manipulate values of type--- @RealWorld@; it\'s only used in the type system, to parameterise @State\#@. --data RealWorld---- |(In a non-concurrent implementation, this can be a singleton--- type, whose (unique) value is returned by @myThreadId\#@. The--- other operations can be omitted.)--data ThreadId#--fork# :: a -> State# (RealWorld) -> (# State# (RealWorld),ThreadId# #)-fork# = let x = x in x--forkOn# :: Int# -> a -> State# (RealWorld) -> (# State# (RealWorld),ThreadId# #)-forkOn# = let x = x in x--killThread# :: ThreadId# -> a -> State# (RealWorld) -> State# (RealWorld)-killThread# = let x = x in x--yield# :: State# (RealWorld) -> State# (RealWorld)-yield# = let x = x in x--myThreadId# :: State# (RealWorld) -> (# State# (RealWorld),ThreadId# #)-myThreadId# = let x = x in x--labelThread# :: ThreadId# -> Addr# -> State# (RealWorld) -> State# (RealWorld)-labelThread# = let x = x in x--isCurrentThreadBound# :: State# (RealWorld) -> (# State# (RealWorld),Int# #)-isCurrentThreadBound# = let x = x in x--noDuplicate# :: State# (RealWorld) -> State# (RealWorld)-noDuplicate# = let x = x in x--threadStatus# :: ThreadId# -> State# (RealWorld) -> (# State# (RealWorld),Int#,Int#,Int# #)-threadStatus# = let x = x in x--data Weak# b--mkWeak# :: o -> b -> c -> State# (RealWorld) -> (# State# (RealWorld),Weak# b #)-mkWeak# = let x = x in x--mkWeakNoFinalizer# :: o -> b -> State# (RealWorld) -> (# State# (RealWorld),Weak# b #)-mkWeakNoFinalizer# = let x = x in x---- | @addCFinalizerToWeak# fptr ptr flag eptr w@ attaches a C--- function pointer @fptr@ to a weak pointer @w@ as a finalizer. If--- @flag@ is zero, @fptr@ will be called with one argument,--- @ptr@. Otherwise, it will be called with two arguments,--- @eptr@ and @ptr@. @addCFinalizerToWeak#@ returns--- 1 on success, or 0 if @w@ is already dead. --addCFinalizerToWeak# :: Addr# -> Addr# -> Int# -> Addr# -> Weak# b -> State# (RealWorld) -> (# State# (RealWorld),Int# #)-addCFinalizerToWeak# = let x = x in x--deRefWeak# :: Weak# a -> State# (RealWorld) -> (# State# (RealWorld),Int#,a #)-deRefWeak# = let x = x in x--finalizeWeak# :: Weak# a -> State# (RealWorld) -> (# State# (RealWorld),Int#,State# (RealWorld) -> (# State# (RealWorld),() #) #)-finalizeWeak# = let x = x in x--touch# :: o -> State# (RealWorld) -> State# (RealWorld)-touch# = let x = x in x--data StablePtr# a--data StableName# a--makeStablePtr# :: a -> State# (RealWorld) -> (# State# (RealWorld),StablePtr# a #)-makeStablePtr# = let x = x in x--deRefStablePtr# :: StablePtr# a -> State# (RealWorld) -> (# State# (RealWorld),a #)-deRefStablePtr# = let x = x in x--eqStablePtr# :: StablePtr# a -> StablePtr# a -> Int#-eqStablePtr# = let x = x in x--makeStableName# :: a -> State# (RealWorld) -> (# State# (RealWorld),StableName# a #)-makeStableName# = let x = x in x--eqStableName# :: StableName# a -> StableName# b -> Int#-eqStableName# = let x = x in x--stableNameToInt# :: StableName# a -> Int#-stableNameToInt# = let x = x in x--reallyUnsafePtrEquality# :: a -> a -> Int#-reallyUnsafePtrEquality# = let x = x in x--par# :: a -> Int#-par# = let x = x in x--spark# :: a -> State# s -> (# State# s,a #)-spark# = let x = x in x--seq# :: a -> State# s -> (# State# s,a #)-seq# = let x = x in x--getSpark# :: State# s -> (# State# s,Int#,a #)-getSpark# = let x = x in x---- | Returns the number of sparks in the local spark pool. --numSparks# :: State# s -> (# State# s,Int# #)-numSparks# = let x = x in x--parGlobal# :: a -> Int# -> Int# -> Int# -> Int# -> b -> Int#-parGlobal# = let x = x in x--parLocal# :: a -> Int# -> Int# -> Int# -> Int# -> b -> Int#-parLocal# = let x = x in x--parAt# :: b -> a -> Int# -> Int# -> Int# -> Int# -> c -> Int#-parAt# = let x = x in x--parAtAbs# :: a -> Int# -> Int# -> Int# -> Int# -> Int# -> b -> Int#-parAtAbs# = let x = x in x--parAtRel# :: a -> Int# -> Int# -> Int# -> Int# -> Int# -> b -> Int#-parAtRel# = let x = x in x--parAtForNow# :: b -> a -> Int# -> Int# -> Int# -> Int# -> c -> Int#-parAtForNow# = let x = x in x--dataToTag# :: a -> Int#-dataToTag# = let x = x in x--tagToEnum# :: Int# -> a-tagToEnum# = let x = x in x---- |Primitive bytecode type.--data BCO#---- |Convert an @Addr\#@ to a followable Any type.--addrToAny# :: Addr# -> (# a #)-addrToAny# = let x = x in x--mkApUpd0# :: BCO# -> (# a #)-mkApUpd0# = let x = x in x--newBCO# :: ByteArray# -> ByteArray# -> Array# a -> Int# -> ByteArray# -> State# s -> (# State# s,BCO# #)-newBCO# = let x = x in x--unpackClosure# :: a -> (# Addr#,Array# b,ByteArray# #)-unpackClosure# = let x = x in x--getApStackVal# :: a -> Int# -> (# Int#,b #)-getApStackVal# = let x = x in x--getCCSOf# :: a -> State# s -> (# State# s,Addr# #)-getCCSOf# = let x = x in x---- | Returns the current @CostCentreStack@ (value is @NULL@ if--- not profiling). Takes a dummy argument which can be used to--- avoid the call to @getCCCS\#@ being floated out by the--- simplifier, which would result in an uninformative stack--- (\"CAF\"). --getCurrentCCS# :: a -> State# s -> (# State# s,Addr# #)-getCurrentCCS# = let x = x in x---- | The type constructor @Proxy#@ is used to bear witness to some--- type variable. It\'s used when you want to pass around proxy values--- for doing things like modelling type applications. A @Proxy#@--- is not only unboxed, it also has a polymorphic kind, and has no--- runtime representation, being totally free. --data Proxy# a---- | Witness for an unboxed @Proxy#@ value, which has no runtime--- representation. --proxy# :: Proxy# a-proxy# = let x = x in x---- | Evaluates its first argument to head normal form, and then returns its second--- argument as the result. --seq :: a -> b -> b-seq = let x = x in x---- | The type constructor @Any@ is type to which you can unsafely coerce any--- lifted type, and back.--- --- * It is lifted, and hence represented by a pointer--- --- * It does not claim to be a /data/ type, and that\'s important for--- the code generator, because the code gen may /enter/ a data value--- but never enters a function value.--- --- It\'s also used to instantiate un-constrained type variables after type--- checking. For example, @length@ has type--- --- @length :: forall a. [a] -> Int@--- --- and the list datacon for the empty list has type--- --- @[] :: forall a. [a]@--- --- In order to compose these two terms as @length []@ a type--- application is required, but there is no constraint on the--- choice. In this situation GHC uses @Any@:--- --- @length (Any *) ([] (Any *))@--- --- Note that @Any@ is kind polymorphic, and takes a kind @k@ as its--- first argument. The kind of @Any@ is thus @forall k. k -> k@.--data Any k---- | The kind @AnyK@ is the kind level counterpart to @Any@. In a--- kind polymorphic setting, a similar example to the length of the empty--- list can be given at the type level:--- --- @type family Length (l :: [k]) :: Nat@--- @type instance Length [] = Zero@--- --- When @Length@ is applied to the empty (promoted) list it will have--- the kind @Length AnyK []@.--- --- @AnyK@ is currently not exported and cannot be used directly, but--- you might see it in debug output from the compiler.--- --data AnyK---- | The function @unsafeCoerce\#@ allows you to side-step the typechecker entirely. That--- is, it allows you to coerce any type into any other type. If you use this function,--- you had better get it right, otherwise segmentation faults await. It is generally--- used when you want to write a program that you know is well-typed, but where Haskell\'s--- type system is not expressive enough to prove that it is well typed.--- --- The following uses of @unsafeCoerce\#@ are supposed to work (i.e. not lead to--- spurious compile-time or run-time crashes):--- --- * Casting any lifted type to @Any@--- --- * Casting @Any@ back to the real type--- --- * Casting an unboxed type to another unboxed type of the same size--- (but not coercions between floating-point and integral types)--- --- * Casting between two types that have the same runtime representation. One case is when--- the two types differ only in \"phantom\" type parameters, for example--- @Ptr Int@ to @Ptr Float@, or @[Int]@ to @[Float]@ when the list is--- known to be empty. Also, a @newtype@ of a type @T@ has the same representation--- at runtime as @T@.--- --- Other uses of @unsafeCoerce\#@ are undefined. In particular, you should not use--- @unsafeCoerce\#@ to cast a T to an algebraic data type D, unless T is also--- an algebraic data type. For example, do not cast @Int->Int@ to @Bool@, even if--- you later cast that @Bool@ back to @Int->Int@ before applying it. The reasons--- have to do with GHC\'s internal representation details (for the congnoscenti, data values--- can be entered but function closures cannot). If you want a safe type to cast things--- to, use @Any@, which is not an algebraic data type.--- --- --unsafeCoerce# :: a -> b-unsafeCoerce# = let x = x in x---- | Emits an event via the RTS tracing framework. The contents--- of the event is the zero-terminated byte string passed as the first--- argument. The event will be emitted either to the .eventlog file,--- or to stderr, depending on the runtime RTS flags. --traceEvent# :: Addr# -> State# s -> State# s-traceEvent# = let x = x in x---- | Emits a marker event via the RTS tracing framework. The contents--- of the event is the zero-terminated byte string passed as the first--- argument. The event will be emitted either to the .eventlog file,--- or to stderr, depending on the runtime RTS flags. --traceMarker# :: Addr# -> State# s -> State# s-traceMarker# = let x = x in x---- | The function @coerce@ allows you to safely convert between values of--- types that have the same representation with no run-time overhead. In the--- simplest case you can use it instead of a newtype constructor, to go from--- the newtype\'s concrete type to the abstract type. But it also works in--- more complicated settings, e.g. converting a list of newtypes to a list of--- concrete types.--- --coerce :: Coercible a b => a -> b-coerce = let x = x in x---- | This two-parameter class has instances for types @a@ and @b@ if--- the compiler can infer that they have the same representation. This class--- does not have regular instances; instead they are created on-the-fly during--- type-checking. Trying to manually declare an instance of @Coercible@--- is an error.--- --- Nevertheless one can pretend that the following three kinds of instances--- exist. First, as a trivial base-case:--- --- @instance a a@--- --- Furthermore, for every type constructor there is--- an instance that allows to coerce under the type constructor. For--- example, let @D@ be a prototypical type constructor (@data@ or @newtype@) with three type arguments, which have roles Nominal,--- Representational resp. Phantom. Then there is an instance of the form--- --- @instance Coercible b b\' => Coercible (D a b c) (D a b\' c\')@--- --- Note that the nominal type arguments are equal, the representational type--- arguments can differ, but need to have a @Coercible@ instance--- themself, and the phantom type arguments can be changed arbitrarily.--- --- In SafeHaskell code, this instance is only usable if the constructors of--- every type constructor used in the definition of @D@ (including--- those of @D@ itself) are in scope.--- --- The third kind of instance exists for every @newtype NT = MkNT T@ and--- comes in two variants, namely--- --- @instance Coercible a T => Coercible a NT@--- --- @instance Coercible T b => Coercible NT b@--- --- This instance is only usable if the constructor @MkNT@ is in scope.--- --- If, as a library author of a type constructor like @Set a@, you--- want to prevent a user of your module to write--- @coerce :: Set T -> Set NT@,--- you need to set the role of @Set@\'s type parameter to Nominal.--- --class Coercible a b--data Int8X16#--data Int16X8#--data Int32X4#--data Int64X2#--data Int8X32#--data Int16X16#--data Int32X8#--data Int64X4#--data Int8X64#--data Int16X32#--data Int32X16#--data Int64X8#--data Word8X16#--data Word16X8#--data Word32X4#--data Word64X2#--data Word8X32#--data Word16X16#--data Word32X8#--data Word64X4#--data Word8X64#--data Word16X32#--data Word32X16#--data Word64X8#--data FloatX4#--data DoubleX2#--data FloatX8#--data DoubleX4#--data FloatX16#--data DoubleX8#---- | Broadcast a scalar to all elements of a vector. --broadcastInt8X16# :: Int# -> Int8X16#-broadcastInt8X16# = let x = x in x---- | Broadcast a scalar to all elements of a vector. --broadcastInt16X8# :: Int# -> Int16X8#-broadcastInt16X8# = let x = x in x---- | Broadcast a scalar to all elements of a vector. --broadcastInt32X4# :: Int# -> Int32X4#-broadcastInt32X4# = let x = x in x---- | Broadcast a scalar to all elements of a vector. --broadcastInt64X2# :: Int# -> Int64X2#-broadcastInt64X2# = let x = x in x---- | Broadcast a scalar to all elements of a vector. --broadcastInt8X32# :: Int# -> Int8X32#-broadcastInt8X32# = let x = x in x---- | Broadcast a scalar to all elements of a vector. --broadcastInt16X16# :: Int# -> Int16X16#-broadcastInt16X16# = let x = x in x---- | Broadcast a scalar to all elements of a vector. --broadcastInt32X8# :: Int# -> Int32X8#-broadcastInt32X8# = let x = x in x---- | Broadcast a scalar to all elements of a vector. --broadcastInt64X4# :: Int# -> Int64X4#-broadcastInt64X4# = let x = x in x---- | Broadcast a scalar to all elements of a vector. --broadcastInt8X64# :: Int# -> Int8X64#-broadcastInt8X64# = let x = x in x---- | Broadcast a scalar to all elements of a vector. --broadcastInt16X32# :: Int# -> Int16X32#-broadcastInt16X32# = let x = x in x---- | Broadcast a scalar to all elements of a vector. --broadcastInt32X16# :: Int# -> Int32X16#-broadcastInt32X16# = let x = x in x---- | Broadcast a scalar to all elements of a vector. --broadcastInt64X8# :: Int# -> Int64X8#-broadcastInt64X8# = let x = x in x---- | Broadcast a scalar to all elements of a vector. --broadcastWord8X16# :: Word# -> Word8X16#-broadcastWord8X16# = let x = x in x---- | Broadcast a scalar to all elements of a vector. --broadcastWord16X8# :: Word# -> Word16X8#-broadcastWord16X8# = let x = x in x---- | Broadcast a scalar to all elements of a vector. --broadcastWord32X4# :: Word# -> Word32X4#-broadcastWord32X4# = let x = x in x---- | Broadcast a scalar to all elements of a vector. --broadcastWord64X2# :: Word# -> Word64X2#-broadcastWord64X2# = let x = x in x---- | Broadcast a scalar to all elements of a vector. --broadcastWord8X32# :: Word# -> Word8X32#-broadcastWord8X32# = let x = x in x---- | Broadcast a scalar to all elements of a vector. --broadcastWord16X16# :: Word# -> Word16X16#-broadcastWord16X16# = let x = x in x---- | Broadcast a scalar to all elements of a vector. --broadcastWord32X8# :: Word# -> Word32X8#-broadcastWord32X8# = let x = x in x---- | Broadcast a scalar to all elements of a vector. --broadcastWord64X4# :: Word# -> Word64X4#-broadcastWord64X4# = let x = x in x---- | Broadcast a scalar to all elements of a vector. --broadcastWord8X64# :: Word# -> Word8X64#-broadcastWord8X64# = let x = x in x---- | Broadcast a scalar to all elements of a vector. --broadcastWord16X32# :: Word# -> Word16X32#-broadcastWord16X32# = let x = x in x---- | Broadcast a scalar to all elements of a vector. --broadcastWord32X16# :: Word# -> Word32X16#-broadcastWord32X16# = let x = x in x---- | Broadcast a scalar to all elements of a vector. --broadcastWord64X8# :: Word# -> Word64X8#-broadcastWord64X8# = let x = x in x---- | Broadcast a scalar to all elements of a vector. --broadcastFloatX4# :: Float# -> FloatX4#-broadcastFloatX4# = let x = x in x---- | Broadcast a scalar to all elements of a vector. --broadcastDoubleX2# :: Double# -> DoubleX2#-broadcastDoubleX2# = let x = x in x---- | Broadcast a scalar to all elements of a vector. --broadcastFloatX8# :: Float# -> FloatX8#-broadcastFloatX8# = let x = x in x---- | Broadcast a scalar to all elements of a vector. --broadcastDoubleX4# :: Double# -> DoubleX4#-broadcastDoubleX4# = let x = x in x---- | Broadcast a scalar to all elements of a vector. --broadcastFloatX16# :: Float# -> FloatX16#-broadcastFloatX16# = let x = x in x---- | Broadcast a scalar to all elements of a vector. --broadcastDoubleX8# :: Double# -> DoubleX8#-broadcastDoubleX8# = let x = x in x---- | Pack the elements of an unboxed tuple into a vector. --packInt8X16# :: (# Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int# #) -> Int8X16#-packInt8X16# = let x = x in x---- | Pack the elements of an unboxed tuple into a vector. --packInt16X8# :: (# Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int# #) -> Int16X8#-packInt16X8# = let x = x in x---- | Pack the elements of an unboxed tuple into a vector. --packInt32X4# :: (# Int#,Int#,Int#,Int# #) -> Int32X4#-packInt32X4# = let x = x in x---- | Pack the elements of an unboxed tuple into a vector. --packInt64X2# :: (# Int#,Int# #) -> Int64X2#-packInt64X2# = let x = x in x---- | Pack the elements of an unboxed tuple into a vector. --packInt8X32# :: (# Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int# #) -> Int8X32#-packInt8X32# = let x = x in x---- | Pack the elements of an unboxed tuple into a vector. --packInt16X16# :: (# Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int# #) -> Int16X16#-packInt16X16# = let x = x in x---- | Pack the elements of an unboxed tuple into a vector. --packInt32X8# :: (# Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int# #) -> Int32X8#-packInt32X8# = let x = x in x---- | Pack the elements of an unboxed tuple into a vector. --packInt64X4# :: (# Int#,Int#,Int#,Int# #) -> Int64X4#-packInt64X4# = let x = x in x---- | Pack the elements of an unboxed tuple into a vector. --packInt8X64# :: (# Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int# #) -> Int8X64#-packInt8X64# = let x = x in x---- | Pack the elements of an unboxed tuple into a vector. --packInt16X32# :: (# Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int# #) -> Int16X32#-packInt16X32# = let x = x in x---- | Pack the elements of an unboxed tuple into a vector. --packInt32X16# :: (# Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int# #) -> Int32X16#-packInt32X16# = let x = x in x---- | Pack the elements of an unboxed tuple into a vector. --packInt64X8# :: (# Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int# #) -> Int64X8#-packInt64X8# = let x = x in x---- | Pack the elements of an unboxed tuple into a vector. --packWord8X16# :: (# Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word# #) -> Word8X16#-packWord8X16# = let x = x in x---- | Pack the elements of an unboxed tuple into a vector. --packWord16X8# :: (# Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word# #) -> Word16X8#-packWord16X8# = let x = x in x---- | Pack the elements of an unboxed tuple into a vector. --packWord32X4# :: (# Word#,Word#,Word#,Word# #) -> Word32X4#-packWord32X4# = let x = x in x---- | Pack the elements of an unboxed tuple into a vector. --packWord64X2# :: (# Word#,Word# #) -> Word64X2#-packWord64X2# = let x = x in x---- | Pack the elements of an unboxed tuple into a vector. --packWord8X32# :: (# Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word# #) -> Word8X32#-packWord8X32# = let x = x in x---- | Pack the elements of an unboxed tuple into a vector. --packWord16X16# :: (# Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word# #) -> Word16X16#-packWord16X16# = let x = x in x---- | Pack the elements of an unboxed tuple into a vector. --packWord32X8# :: (# Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word# #) -> Word32X8#-packWord32X8# = let x = x in x---- | Pack the elements of an unboxed tuple into a vector. --packWord64X4# :: (# Word#,Word#,Word#,Word# #) -> Word64X4#-packWord64X4# = let x = x in x---- | Pack the elements of an unboxed tuple into a vector. --packWord8X64# :: (# Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word# #) -> Word8X64#-packWord8X64# = let x = x in x---- | Pack the elements of an unboxed tuple into a vector. --packWord16X32# :: (# Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word# #) -> Word16X32#-packWord16X32# = let x = x in x---- | Pack the elements of an unboxed tuple into a vector. --packWord32X16# :: (# Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word# #) -> Word32X16#-packWord32X16# = let x = x in x---- | Pack the elements of an unboxed tuple into a vector. --packWord64X8# :: (# Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word# #) -> Word64X8#-packWord64X8# = let x = x in x---- | Pack the elements of an unboxed tuple into a vector. --packFloatX4# :: (# Float#,Float#,Float#,Float# #) -> FloatX4#-packFloatX4# = let x = x in x---- | Pack the elements of an unboxed tuple into a vector. --packDoubleX2# :: (# Double#,Double# #) -> DoubleX2#-packDoubleX2# = let x = x in x---- | Pack the elements of an unboxed tuple into a vector. --packFloatX8# :: (# Float#,Float#,Float#,Float#,Float#,Float#,Float#,Float# #) -> FloatX8#-packFloatX8# = let x = x in x---- | Pack the elements of an unboxed tuple into a vector. --packDoubleX4# :: (# Double#,Double#,Double#,Double# #) -> DoubleX4#-packDoubleX4# = let x = x in x---- | Pack the elements of an unboxed tuple into a vector. --packFloatX16# :: (# Float#,Float#,Float#,Float#,Float#,Float#,Float#,Float#,Float#,Float#,Float#,Float#,Float#,Float#,Float#,Float# #) -> FloatX16#-packFloatX16# = let x = x in x---- | Pack the elements of an unboxed tuple into a vector. --packDoubleX8# :: (# Double#,Double#,Double#,Double#,Double#,Double#,Double#,Double# #) -> DoubleX8#-packDoubleX8# = let x = x in x---- | Unpack the elements of a vector into an unboxed tuple. #--unpackInt8X16# :: Int8X16# -> (# Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int# #)-unpackInt8X16# = let x = x in x---- | Unpack the elements of a vector into an unboxed tuple. #--unpackInt16X8# :: Int16X8# -> (# Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int# #)-unpackInt16X8# = let x = x in x---- | Unpack the elements of a vector into an unboxed tuple. #--unpackInt32X4# :: Int32X4# -> (# Int#,Int#,Int#,Int# #)-unpackInt32X4# = let x = x in x---- | Unpack the elements of a vector into an unboxed tuple. #--unpackInt64X2# :: Int64X2# -> (# Int#,Int# #)-unpackInt64X2# = let x = x in x---- | Unpack the elements of a vector into an unboxed tuple. #--unpackInt8X32# :: Int8X32# -> (# Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int# #)-unpackInt8X32# = let x = x in x---- | Unpack the elements of a vector into an unboxed tuple. #--unpackInt16X16# :: Int16X16# -> (# Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int# #)-unpackInt16X16# = let x = x in x---- | Unpack the elements of a vector into an unboxed tuple. #--unpackInt32X8# :: Int32X8# -> (# Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int# #)-unpackInt32X8# = let x = x in x---- | Unpack the elements of a vector into an unboxed tuple. #--unpackInt64X4# :: Int64X4# -> (# Int#,Int#,Int#,Int# #)-unpackInt64X4# = let x = x in x---- | Unpack the elements of a vector into an unboxed tuple. #--unpackInt8X64# :: Int8X64# -> (# Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int# #)-unpackInt8X64# = let x = x in x---- | Unpack the elements of a vector into an unboxed tuple. #--unpackInt16X32# :: Int16X32# -> (# Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int# #)-unpackInt16X32# = let x = x in x---- | Unpack the elements of a vector into an unboxed tuple. #--unpackInt32X16# :: Int32X16# -> (# Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int# #)-unpackInt32X16# = let x = x in x---- | Unpack the elements of a vector into an unboxed tuple. #--unpackInt64X8# :: Int64X8# -> (# Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int# #)-unpackInt64X8# = let x = x in x---- | Unpack the elements of a vector into an unboxed tuple. #--unpackWord8X16# :: Word8X16# -> (# Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word# #)-unpackWord8X16# = let x = x in x---- | Unpack the elements of a vector into an unboxed tuple. #--unpackWord16X8# :: Word16X8# -> (# Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word# #)-unpackWord16X8# = let x = x in x---- | Unpack the elements of a vector into an unboxed tuple. #--unpackWord32X4# :: Word32X4# -> (# Word#,Word#,Word#,Word# #)-unpackWord32X4# = let x = x in x---- | Unpack the elements of a vector into an unboxed tuple. #--unpackWord64X2# :: Word64X2# -> (# Word#,Word# #)-unpackWord64X2# = let x = x in x---- | Unpack the elements of a vector into an unboxed tuple. #--unpackWord8X32# :: Word8X32# -> (# Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word# #)-unpackWord8X32# = let x = x in x---- | Unpack the elements of a vector into an unboxed tuple. #--unpackWord16X16# :: Word16X16# -> (# Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word# #)-unpackWord16X16# = let x = x in x---- | Unpack the elements of a vector into an unboxed tuple. #--unpackWord32X8# :: Word32X8# -> (# Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word# #)-unpackWord32X8# = let x = x in x---- | Unpack the elements of a vector into an unboxed tuple. #--unpackWord64X4# :: Word64X4# -> (# Word#,Word#,Word#,Word# #)-unpackWord64X4# = let x = x in x---- | Unpack the elements of a vector into an unboxed tuple. #--unpackWord8X64# :: Word8X64# -> (# Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word# #)-unpackWord8X64# = let x = x in x---- | Unpack the elements of a vector into an unboxed tuple. #--unpackWord16X32# :: Word16X32# -> (# Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word# #)-unpackWord16X32# = let x = x in x---- | Unpack the elements of a vector into an unboxed tuple. #--unpackWord32X16# :: Word32X16# -> (# Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word# #)-unpackWord32X16# = let x = x in x---- | Unpack the elements of a vector into an unboxed tuple. #--unpackWord64X8# :: Word64X8# -> (# Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word# #)-unpackWord64X8# = let x = x in x---- | Unpack the elements of a vector into an unboxed tuple. #--unpackFloatX4# :: FloatX4# -> (# Float#,Float#,Float#,Float# #)-unpackFloatX4# = let x = x in x---- | Unpack the elements of a vector into an unboxed tuple. #--unpackDoubleX2# :: DoubleX2# -> (# Double#,Double# #)-unpackDoubleX2# = let x = x in x---- | Unpack the elements of a vector into an unboxed tuple. #--unpackFloatX8# :: FloatX8# -> (# Float#,Float#,Float#,Float#,Float#,Float#,Float#,Float# #)-unpackFloatX8# = let x = x in x---- | Unpack the elements of a vector into an unboxed tuple. #--unpackDoubleX4# :: DoubleX4# -> (# Double#,Double#,Double#,Double# #)-unpackDoubleX4# = let x = x in x---- | Unpack the elements of a vector into an unboxed tuple. #--unpackFloatX16# :: FloatX16# -> (# Float#,Float#,Float#,Float#,Float#,Float#,Float#,Float#,Float#,Float#,Float#,Float#,Float#,Float#,Float#,Float# #)-unpackFloatX16# = let x = x in x---- | Unpack the elements of a vector into an unboxed tuple. #--unpackDoubleX8# :: DoubleX8# -> (# Double#,Double#,Double#,Double#,Double#,Double#,Double#,Double# #)-unpackDoubleX8# = let x = x in x---- | Insert a scalar at the given position in a vector. --insertInt8X16# :: Int8X16# -> Int# -> Int# -> Int8X16#-insertInt8X16# = let x = x in x---- | Insert a scalar at the given position in a vector. --insertInt16X8# :: Int16X8# -> Int# -> Int# -> Int16X8#-insertInt16X8# = let x = x in x---- | Insert a scalar at the given position in a vector. --insertInt32X4# :: Int32X4# -> Int# -> Int# -> Int32X4#-insertInt32X4# = let x = x in x---- | Insert a scalar at the given position in a vector. --insertInt64X2# :: Int64X2# -> Int# -> Int# -> Int64X2#-insertInt64X2# = let x = x in x---- | Insert a scalar at the given position in a vector. --insertInt8X32# :: Int8X32# -> Int# -> Int# -> Int8X32#-insertInt8X32# = let x = x in x---- | Insert a scalar at the given position in a vector. --insertInt16X16# :: Int16X16# -> Int# -> Int# -> Int16X16#-insertInt16X16# = let x = x in x---- | Insert a scalar at the given position in a vector. --insertInt32X8# :: Int32X8# -> Int# -> Int# -> Int32X8#-insertInt32X8# = let x = x in x---- | Insert a scalar at the given position in a vector. --insertInt64X4# :: Int64X4# -> Int# -> Int# -> Int64X4#-insertInt64X4# = let x = x in x---- | Insert a scalar at the given position in a vector. --insertInt8X64# :: Int8X64# -> Int# -> Int# -> Int8X64#-insertInt8X64# = let x = x in x---- | Insert a scalar at the given position in a vector. --insertInt16X32# :: Int16X32# -> Int# -> Int# -> Int16X32#-insertInt16X32# = let x = x in x---- | Insert a scalar at the given position in a vector. --insertInt32X16# :: Int32X16# -> Int# -> Int# -> Int32X16#-insertInt32X16# = let x = x in x---- | Insert a scalar at the given position in a vector. --insertInt64X8# :: Int64X8# -> Int# -> Int# -> Int64X8#-insertInt64X8# = let x = x in x---- | Insert a scalar at the given position in a vector. --insertWord8X16# :: Word8X16# -> Word# -> Int# -> Word8X16#-insertWord8X16# = let x = x in x---- | Insert a scalar at the given position in a vector. --insertWord16X8# :: Word16X8# -> Word# -> Int# -> Word16X8#-insertWord16X8# = let x = x in x---- | Insert a scalar at the given position in a vector. --insertWord32X4# :: Word32X4# -> Word# -> Int# -> Word32X4#-insertWord32X4# = let x = x in x---- | Insert a scalar at the given position in a vector. --insertWord64X2# :: Word64X2# -> Word# -> Int# -> Word64X2#-insertWord64X2# = let x = x in x---- | Insert a scalar at the given position in a vector. --insertWord8X32# :: Word8X32# -> Word# -> Int# -> Word8X32#-insertWord8X32# = let x = x in x---- | Insert a scalar at the given position in a vector. --insertWord16X16# :: Word16X16# -> Word# -> Int# -> Word16X16#-insertWord16X16# = let x = x in x---- | Insert a scalar at the given position in a vector. --insertWord32X8# :: Word32X8# -> Word# -> Int# -> Word32X8#-insertWord32X8# = let x = x in x---- | Insert a scalar at the given position in a vector. --insertWord64X4# :: Word64X4# -> Word# -> Int# -> Word64X4#-insertWord64X4# = let x = x in x---- | Insert a scalar at the given position in a vector. --insertWord8X64# :: Word8X64# -> Word# -> Int# -> Word8X64#-insertWord8X64# = let x = x in x---- | Insert a scalar at the given position in a vector. --insertWord16X32# :: Word16X32# -> Word# -> Int# -> Word16X32#-insertWord16X32# = let x = x in x---- | Insert a scalar at the given position in a vector. --insertWord32X16# :: Word32X16# -> Word# -> Int# -> Word32X16#-insertWord32X16# = let x = x in x---- | Insert a scalar at the given position in a vector. --insertWord64X8# :: Word64X8# -> Word# -> Int# -> Word64X8#-insertWord64X8# = let x = x in x---- | Insert a scalar at the given position in a vector. --insertFloatX4# :: FloatX4# -> Float# -> Int# -> FloatX4#-insertFloatX4# = let x = x in x---- | Insert a scalar at the given position in a vector. --insertDoubleX2# :: DoubleX2# -> Double# -> Int# -> DoubleX2#-insertDoubleX2# = let x = x in x---- | Insert a scalar at the given position in a vector. --insertFloatX8# :: FloatX8# -> Float# -> Int# -> FloatX8#-insertFloatX8# = let x = x in x---- | Insert a scalar at the given position in a vector. --insertDoubleX4# :: DoubleX4# -> Double# -> Int# -> DoubleX4#-insertDoubleX4# = let x = x in x---- | Insert a scalar at the given position in a vector. --insertFloatX16# :: FloatX16# -> Float# -> Int# -> FloatX16#-insertFloatX16# = let x = x in x---- | Insert a scalar at the given position in a vector. --insertDoubleX8# :: DoubleX8# -> Double# -> Int# -> DoubleX8#-insertDoubleX8# = let x = x in x---- | Add two vectors element-wise. --plusInt8X16# :: Int8X16# -> Int8X16# -> Int8X16#-plusInt8X16# = let x = x in x---- | Add two vectors element-wise. --plusInt16X8# :: Int16X8# -> Int16X8# -> Int16X8#-plusInt16X8# = let x = x in x---- | Add two vectors element-wise. --plusInt32X4# :: Int32X4# -> Int32X4# -> Int32X4#-plusInt32X4# = let x = x in x---- | Add two vectors element-wise. --plusInt64X2# :: Int64X2# -> Int64X2# -> Int64X2#-plusInt64X2# = let x = x in x---- | Add two vectors element-wise. --plusInt8X32# :: Int8X32# -> Int8X32# -> Int8X32#-plusInt8X32# = let x = x in x---- | Add two vectors element-wise. --plusInt16X16# :: Int16X16# -> Int16X16# -> Int16X16#-plusInt16X16# = let x = x in x---- | Add two vectors element-wise. --plusInt32X8# :: Int32X8# -> Int32X8# -> Int32X8#-plusInt32X8# = let x = x in x---- | Add two vectors element-wise. --plusInt64X4# :: Int64X4# -> Int64X4# -> Int64X4#-plusInt64X4# = let x = x in x---- | Add two vectors element-wise. --plusInt8X64# :: Int8X64# -> Int8X64# -> Int8X64#-plusInt8X64# = let x = x in x---- | Add two vectors element-wise. --plusInt16X32# :: Int16X32# -> Int16X32# -> Int16X32#-plusInt16X32# = let x = x in x---- | Add two vectors element-wise. --plusInt32X16# :: Int32X16# -> Int32X16# -> Int32X16#-plusInt32X16# = let x = x in x---- | Add two vectors element-wise. --plusInt64X8# :: Int64X8# -> Int64X8# -> Int64X8#-plusInt64X8# = let x = x in x---- | Add two vectors element-wise. --plusWord8X16# :: Word8X16# -> Word8X16# -> Word8X16#-plusWord8X16# = let x = x in x---- | Add two vectors element-wise. --plusWord16X8# :: Word16X8# -> Word16X8# -> Word16X8#-plusWord16X8# = let x = x in x---- | Add two vectors element-wise. --plusWord32X4# :: Word32X4# -> Word32X4# -> Word32X4#-plusWord32X4# = let x = x in x---- | Add two vectors element-wise. --plusWord64X2# :: Word64X2# -> Word64X2# -> Word64X2#-plusWord64X2# = let x = x in x---- | Add two vectors element-wise. --plusWord8X32# :: Word8X32# -> Word8X32# -> Word8X32#-plusWord8X32# = let x = x in x---- | Add two vectors element-wise. --plusWord16X16# :: Word16X16# -> Word16X16# -> Word16X16#-plusWord16X16# = let x = x in x---- | Add two vectors element-wise. --plusWord32X8# :: Word32X8# -> Word32X8# -> Word32X8#-plusWord32X8# = let x = x in x---- | Add two vectors element-wise. --plusWord64X4# :: Word64X4# -> Word64X4# -> Word64X4#-plusWord64X4# = let x = x in x---- | Add two vectors element-wise. --plusWord8X64# :: Word8X64# -> Word8X64# -> Word8X64#-plusWord8X64# = let x = x in x---- | Add two vectors element-wise. --plusWord16X32# :: Word16X32# -> Word16X32# -> Word16X32#-plusWord16X32# = let x = x in x---- | Add two vectors element-wise. --plusWord32X16# :: Word32X16# -> Word32X16# -> Word32X16#-plusWord32X16# = let x = x in x---- | Add two vectors element-wise. --plusWord64X8# :: Word64X8# -> Word64X8# -> Word64X8#-plusWord64X8# = let x = x in x---- | Add two vectors element-wise. --plusFloatX4# :: FloatX4# -> FloatX4# -> FloatX4#-plusFloatX4# = let x = x in x---- | Add two vectors element-wise. --plusDoubleX2# :: DoubleX2# -> DoubleX2# -> DoubleX2#-plusDoubleX2# = let x = x in x---- | Add two vectors element-wise. --plusFloatX8# :: FloatX8# -> FloatX8# -> FloatX8#-plusFloatX8# = let x = x in x---- | Add two vectors element-wise. --plusDoubleX4# :: DoubleX4# -> DoubleX4# -> DoubleX4#-plusDoubleX4# = let x = x in x---- | Add two vectors element-wise. --plusFloatX16# :: FloatX16# -> FloatX16# -> FloatX16#-plusFloatX16# = let x = x in x---- | Add two vectors element-wise. --plusDoubleX8# :: DoubleX8# -> DoubleX8# -> DoubleX8#-plusDoubleX8# = let x = x in x---- | Subtract two vectors element-wise. --minusInt8X16# :: Int8X16# -> Int8X16# -> Int8X16#-minusInt8X16# = let x = x in x---- | Subtract two vectors element-wise. --minusInt16X8# :: Int16X8# -> Int16X8# -> Int16X8#-minusInt16X8# = let x = x in x---- | Subtract two vectors element-wise. --minusInt32X4# :: Int32X4# -> Int32X4# -> Int32X4#-minusInt32X4# = let x = x in x---- | Subtract two vectors element-wise. --minusInt64X2# :: Int64X2# -> Int64X2# -> Int64X2#-minusInt64X2# = let x = x in x---- | Subtract two vectors element-wise. --minusInt8X32# :: Int8X32# -> Int8X32# -> Int8X32#-minusInt8X32# = let x = x in x---- | Subtract two vectors element-wise. --minusInt16X16# :: Int16X16# -> Int16X16# -> Int16X16#-minusInt16X16# = let x = x in x---- | Subtract two vectors element-wise. --minusInt32X8# :: Int32X8# -> Int32X8# -> Int32X8#-minusInt32X8# = let x = x in x---- | Subtract two vectors element-wise. --minusInt64X4# :: Int64X4# -> Int64X4# -> Int64X4#-minusInt64X4# = let x = x in x---- | Subtract two vectors element-wise. --minusInt8X64# :: Int8X64# -> Int8X64# -> Int8X64#-minusInt8X64# = let x = x in x---- | Subtract two vectors element-wise. --minusInt16X32# :: Int16X32# -> Int16X32# -> Int16X32#-minusInt16X32# = let x = x in x---- | Subtract two vectors element-wise. --minusInt32X16# :: Int32X16# -> Int32X16# -> Int32X16#-minusInt32X16# = let x = x in x---- | Subtract two vectors element-wise. --minusInt64X8# :: Int64X8# -> Int64X8# -> Int64X8#-minusInt64X8# = let x = x in x---- | Subtract two vectors element-wise. --minusWord8X16# :: Word8X16# -> Word8X16# -> Word8X16#-minusWord8X16# = let x = x in x---- | Subtract two vectors element-wise. --minusWord16X8# :: Word16X8# -> Word16X8# -> Word16X8#-minusWord16X8# = let x = x in x---- | Subtract two vectors element-wise. --minusWord32X4# :: Word32X4# -> Word32X4# -> Word32X4#-minusWord32X4# = let x = x in x---- | Subtract two vectors element-wise. --minusWord64X2# :: Word64X2# -> Word64X2# -> Word64X2#-minusWord64X2# = let x = x in x---- | Subtract two vectors element-wise. --minusWord8X32# :: Word8X32# -> Word8X32# -> Word8X32#-minusWord8X32# = let x = x in x---- | Subtract two vectors element-wise. --minusWord16X16# :: Word16X16# -> Word16X16# -> Word16X16#-minusWord16X16# = let x = x in x---- | Subtract two vectors element-wise. --minusWord32X8# :: Word32X8# -> Word32X8# -> Word32X8#-minusWord32X8# = let x = x in x---- | Subtract two vectors element-wise. --minusWord64X4# :: Word64X4# -> Word64X4# -> Word64X4#-minusWord64X4# = let x = x in x---- | Subtract two vectors element-wise. --minusWord8X64# :: Word8X64# -> Word8X64# -> Word8X64#-minusWord8X64# = let x = x in x---- | Subtract two vectors element-wise. --minusWord16X32# :: Word16X32# -> Word16X32# -> Word16X32#-minusWord16X32# = let x = x in x---- | Subtract two vectors element-wise. --minusWord32X16# :: Word32X16# -> Word32X16# -> Word32X16#-minusWord32X16# = let x = x in x---- | Subtract two vectors element-wise. --minusWord64X8# :: Word64X8# -> Word64X8# -> Word64X8#-minusWord64X8# = let x = x in x---- | Subtract two vectors element-wise. --minusFloatX4# :: FloatX4# -> FloatX4# -> FloatX4#-minusFloatX4# = let x = x in x---- | Subtract two vectors element-wise. --minusDoubleX2# :: DoubleX2# -> DoubleX2# -> DoubleX2#-minusDoubleX2# = let x = x in x---- | Subtract two vectors element-wise. --minusFloatX8# :: FloatX8# -> FloatX8# -> FloatX8#-minusFloatX8# = let x = x in x---- | Subtract two vectors element-wise. --minusDoubleX4# :: DoubleX4# -> DoubleX4# -> DoubleX4#-minusDoubleX4# = let x = x in x---- | Subtract two vectors element-wise. --minusFloatX16# :: FloatX16# -> FloatX16# -> FloatX16#-minusFloatX16# = let x = x in x---- | Subtract two vectors element-wise. --minusDoubleX8# :: DoubleX8# -> DoubleX8# -> DoubleX8#-minusDoubleX8# = let x = x in x---- | Multiply two vectors element-wise. --timesInt8X16# :: Int8X16# -> Int8X16# -> Int8X16#-timesInt8X16# = let x = x in x---- | Multiply two vectors element-wise. --timesInt16X8# :: Int16X8# -> Int16X8# -> Int16X8#-timesInt16X8# = let x = x in x---- | Multiply two vectors element-wise. --timesInt32X4# :: Int32X4# -> Int32X4# -> Int32X4#-timesInt32X4# = let x = x in x---- | Multiply two vectors element-wise. --timesInt64X2# :: Int64X2# -> Int64X2# -> Int64X2#-timesInt64X2# = let x = x in x---- | Multiply two vectors element-wise. --timesInt8X32# :: Int8X32# -> Int8X32# -> Int8X32#-timesInt8X32# = let x = x in x---- | Multiply two vectors element-wise. --timesInt16X16# :: Int16X16# -> Int16X16# -> Int16X16#-timesInt16X16# = let x = x in x---- | Multiply two vectors element-wise. --timesInt32X8# :: Int32X8# -> Int32X8# -> Int32X8#-timesInt32X8# = let x = x in x---- | Multiply two vectors element-wise. --timesInt64X4# :: Int64X4# -> Int64X4# -> Int64X4#-timesInt64X4# = let x = x in x---- | Multiply two vectors element-wise. --timesInt8X64# :: Int8X64# -> Int8X64# -> Int8X64#-timesInt8X64# = let x = x in x---- | Multiply two vectors element-wise. --timesInt16X32# :: Int16X32# -> Int16X32# -> Int16X32#-timesInt16X32# = let x = x in x---- | Multiply two vectors element-wise. --timesInt32X16# :: Int32X16# -> Int32X16# -> Int32X16#-timesInt32X16# = let x = x in x---- | Multiply two vectors element-wise. --timesInt64X8# :: Int64X8# -> Int64X8# -> Int64X8#-timesInt64X8# = let x = x in x---- | Multiply two vectors element-wise. --timesWord8X16# :: Word8X16# -> Word8X16# -> Word8X16#-timesWord8X16# = let x = x in x---- | Multiply two vectors element-wise. --timesWord16X8# :: Word16X8# -> Word16X8# -> Word16X8#-timesWord16X8# = let x = x in x---- | Multiply two vectors element-wise. --timesWord32X4# :: Word32X4# -> Word32X4# -> Word32X4#-timesWord32X4# = let x = x in x---- | Multiply two vectors element-wise. --timesWord64X2# :: Word64X2# -> Word64X2# -> Word64X2#-timesWord64X2# = let x = x in x---- | Multiply two vectors element-wise. --timesWord8X32# :: Word8X32# -> Word8X32# -> Word8X32#-timesWord8X32# = let x = x in x---- | Multiply two vectors element-wise. --timesWord16X16# :: Word16X16# -> Word16X16# -> Word16X16#-timesWord16X16# = let x = x in x---- | Multiply two vectors element-wise. --timesWord32X8# :: Word32X8# -> Word32X8# -> Word32X8#-timesWord32X8# = let x = x in x---- | Multiply two vectors element-wise. --timesWord64X4# :: Word64X4# -> Word64X4# -> Word64X4#-timesWord64X4# = let x = x in x---- | Multiply two vectors element-wise. --timesWord8X64# :: Word8X64# -> Word8X64# -> Word8X64#-timesWord8X64# = let x = x in x---- | Multiply two vectors element-wise. --timesWord16X32# :: Word16X32# -> Word16X32# -> Word16X32#-timesWord16X32# = let x = x in x---- | Multiply two vectors element-wise. --timesWord32X16# :: Word32X16# -> Word32X16# -> Word32X16#-timesWord32X16# = let x = x in x---- | Multiply two vectors element-wise. --timesWord64X8# :: Word64X8# -> Word64X8# -> Word64X8#-timesWord64X8# = let x = x in x---- | Multiply two vectors element-wise. --timesFloatX4# :: FloatX4# -> FloatX4# -> FloatX4#-timesFloatX4# = let x = x in x---- | Multiply two vectors element-wise. --timesDoubleX2# :: DoubleX2# -> DoubleX2# -> DoubleX2#-timesDoubleX2# = let x = x in x---- | Multiply two vectors element-wise. --timesFloatX8# :: FloatX8# -> FloatX8# -> FloatX8#-timesFloatX8# = let x = x in x---- | Multiply two vectors element-wise. --timesDoubleX4# :: DoubleX4# -> DoubleX4# -> DoubleX4#-timesDoubleX4# = let x = x in x---- | Multiply two vectors element-wise. --timesFloatX16# :: FloatX16# -> FloatX16# -> FloatX16#-timesFloatX16# = let x = x in x---- | Multiply two vectors element-wise. --timesDoubleX8# :: DoubleX8# -> DoubleX8# -> DoubleX8#-timesDoubleX8# = let x = x in x---- | Divide two vectors element-wise. --divideFloatX4# :: FloatX4# -> FloatX4# -> FloatX4#-divideFloatX4# = let x = x in x---- | Divide two vectors element-wise. --divideDoubleX2# :: DoubleX2# -> DoubleX2# -> DoubleX2#-divideDoubleX2# = let x = x in x---- | Divide two vectors element-wise. --divideFloatX8# :: FloatX8# -> FloatX8# -> FloatX8#-divideFloatX8# = let x = x in x---- | Divide two vectors element-wise. --divideDoubleX4# :: DoubleX4# -> DoubleX4# -> DoubleX4#-divideDoubleX4# = let x = x in x---- | Divide two vectors element-wise. --divideFloatX16# :: FloatX16# -> FloatX16# -> FloatX16#-divideFloatX16# = let x = x in x---- | Divide two vectors element-wise. --divideDoubleX8# :: DoubleX8# -> DoubleX8# -> DoubleX8#-divideDoubleX8# = let x = x in x---- | Rounds towards zero element-wise. --quotInt8X16# :: Int8X16# -> Int8X16# -> Int8X16#-quotInt8X16# = let x = x in x---- | Rounds towards zero element-wise. --quotInt16X8# :: Int16X8# -> Int16X8# -> Int16X8#-quotInt16X8# = let x = x in x---- | Rounds towards zero element-wise. --quotInt32X4# :: Int32X4# -> Int32X4# -> Int32X4#-quotInt32X4# = let x = x in x---- | Rounds towards zero element-wise. --quotInt64X2# :: Int64X2# -> Int64X2# -> Int64X2#-quotInt64X2# = let x = x in x---- | Rounds towards zero element-wise. --quotInt8X32# :: Int8X32# -> Int8X32# -> Int8X32#-quotInt8X32# = let x = x in x---- | Rounds towards zero element-wise. --quotInt16X16# :: Int16X16# -> Int16X16# -> Int16X16#-quotInt16X16# = let x = x in x---- | Rounds towards zero element-wise. --quotInt32X8# :: Int32X8# -> Int32X8# -> Int32X8#-quotInt32X8# = let x = x in x---- | Rounds towards zero element-wise. --quotInt64X4# :: Int64X4# -> Int64X4# -> Int64X4#-quotInt64X4# = let x = x in x---- | Rounds towards zero element-wise. --quotInt8X64# :: Int8X64# -> Int8X64# -> Int8X64#-quotInt8X64# = let x = x in x---- | Rounds towards zero element-wise. --quotInt16X32# :: Int16X32# -> Int16X32# -> Int16X32#-quotInt16X32# = let x = x in x---- | Rounds towards zero element-wise. --quotInt32X16# :: Int32X16# -> Int32X16# -> Int32X16#-quotInt32X16# = let x = x in x---- | Rounds towards zero element-wise. --quotInt64X8# :: Int64X8# -> Int64X8# -> Int64X8#-quotInt64X8# = let x = x in x---- | Rounds towards zero element-wise. --quotWord8X16# :: Word8X16# -> Word8X16# -> Word8X16#-quotWord8X16# = let x = x in x---- | Rounds towards zero element-wise. --quotWord16X8# :: Word16X8# -> Word16X8# -> Word16X8#-quotWord16X8# = let x = x in x---- | Rounds towards zero element-wise. --quotWord32X4# :: Word32X4# -> Word32X4# -> Word32X4#-quotWord32X4# = let x = x in x---- | Rounds towards zero element-wise. --quotWord64X2# :: Word64X2# -> Word64X2# -> Word64X2#-quotWord64X2# = let x = x in x---- | Rounds towards zero element-wise. --quotWord8X32# :: Word8X32# -> Word8X32# -> Word8X32#-quotWord8X32# = let x = x in x---- | Rounds towards zero element-wise. --quotWord16X16# :: Word16X16# -> Word16X16# -> Word16X16#-quotWord16X16# = let x = x in x---- | Rounds towards zero element-wise. --quotWord32X8# :: Word32X8# -> Word32X8# -> Word32X8#-quotWord32X8# = let x = x in x---- | Rounds towards zero element-wise. --quotWord64X4# :: Word64X4# -> Word64X4# -> Word64X4#-quotWord64X4# = let x = x in x---- | Rounds towards zero element-wise. --quotWord8X64# :: Word8X64# -> Word8X64# -> Word8X64#-quotWord8X64# = let x = x in x---- | Rounds towards zero element-wise. --quotWord16X32# :: Word16X32# -> Word16X32# -> Word16X32#-quotWord16X32# = let x = x in x---- | Rounds towards zero element-wise. --quotWord32X16# :: Word32X16# -> Word32X16# -> Word32X16#-quotWord32X16# = let x = x in x---- | Rounds towards zero element-wise. --quotWord64X8# :: Word64X8# -> Word64X8# -> Word64X8#-quotWord64X8# = let x = x in x---- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. --remInt8X16# :: Int8X16# -> Int8X16# -> Int8X16#-remInt8X16# = let x = x in x---- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. --remInt16X8# :: Int16X8# -> Int16X8# -> Int16X8#-remInt16X8# = let x = x in x---- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. --remInt32X4# :: Int32X4# -> Int32X4# -> Int32X4#-remInt32X4# = let x = x in x---- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. --remInt64X2# :: Int64X2# -> Int64X2# -> Int64X2#-remInt64X2# = let x = x in x---- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. --remInt8X32# :: Int8X32# -> Int8X32# -> Int8X32#-remInt8X32# = let x = x in x---- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. --remInt16X16# :: Int16X16# -> Int16X16# -> Int16X16#-remInt16X16# = let x = x in x---- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. --remInt32X8# :: Int32X8# -> Int32X8# -> Int32X8#-remInt32X8# = let x = x in x---- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. --remInt64X4# :: Int64X4# -> Int64X4# -> Int64X4#-remInt64X4# = let x = x in x---- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. --remInt8X64# :: Int8X64# -> Int8X64# -> Int8X64#-remInt8X64# = let x = x in x---- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. --remInt16X32# :: Int16X32# -> Int16X32# -> Int16X32#-remInt16X32# = let x = x in x---- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. --remInt32X16# :: Int32X16# -> Int32X16# -> Int32X16#-remInt32X16# = let x = x in x---- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. --remInt64X8# :: Int64X8# -> Int64X8# -> Int64X8#-remInt64X8# = let x = x in x---- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. --remWord8X16# :: Word8X16# -> Word8X16# -> Word8X16#-remWord8X16# = let x = x in x---- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. --remWord16X8# :: Word16X8# -> Word16X8# -> Word16X8#-remWord16X8# = let x = x in x---- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. --remWord32X4# :: Word32X4# -> Word32X4# -> Word32X4#-remWord32X4# = let x = x in x---- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. --remWord64X2# :: Word64X2# -> Word64X2# -> Word64X2#-remWord64X2# = let x = x in x---- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. --remWord8X32# :: Word8X32# -> Word8X32# -> Word8X32#-remWord8X32# = let x = x in x---- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. --remWord16X16# :: Word16X16# -> Word16X16# -> Word16X16#-remWord16X16# = let x = x in x---- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. --remWord32X8# :: Word32X8# -> Word32X8# -> Word32X8#-remWord32X8# = let x = x in x---- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. --remWord64X4# :: Word64X4# -> Word64X4# -> Word64X4#-remWord64X4# = let x = x in x---- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. --remWord8X64# :: Word8X64# -> Word8X64# -> Word8X64#-remWord8X64# = let x = x in x---- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. --remWord16X32# :: Word16X32# -> Word16X32# -> Word16X32#-remWord16X32# = let x = x in x---- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. --remWord32X16# :: Word32X16# -> Word32X16# -> Word32X16#-remWord32X16# = let x = x in x---- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. --remWord64X8# :: Word64X8# -> Word64X8# -> Word64X8#-remWord64X8# = let x = x in x---- | Negate element-wise. --negateInt8X16# :: Int8X16# -> Int8X16#-negateInt8X16# = let x = x in x---- | Negate element-wise. --negateInt16X8# :: Int16X8# -> Int16X8#-negateInt16X8# = let x = x in x---- | Negate element-wise. --negateInt32X4# :: Int32X4# -> Int32X4#-negateInt32X4# = let x = x in x---- | Negate element-wise. --negateInt64X2# :: Int64X2# -> Int64X2#-negateInt64X2# = let x = x in x---- | Negate element-wise. --negateInt8X32# :: Int8X32# -> Int8X32#-negateInt8X32# = let x = x in x---- | Negate element-wise. --negateInt16X16# :: Int16X16# -> Int16X16#-negateInt16X16# = let x = x in x---- | Negate element-wise. --negateInt32X8# :: Int32X8# -> Int32X8#-negateInt32X8# = let x = x in x---- | Negate element-wise. --negateInt64X4# :: Int64X4# -> Int64X4#-negateInt64X4# = let x = x in x---- | Negate element-wise. --negateInt8X64# :: Int8X64# -> Int8X64#-negateInt8X64# = let x = x in x---- | Negate element-wise. --negateInt16X32# :: Int16X32# -> Int16X32#-negateInt16X32# = let x = x in x---- | Negate element-wise. --negateInt32X16# :: Int32X16# -> Int32X16#-negateInt32X16# = let x = x in x---- | Negate element-wise. --negateInt64X8# :: Int64X8# -> Int64X8#-negateInt64X8# = let x = x in x---- | Negate element-wise. --negateFloatX4# :: FloatX4# -> FloatX4#-negateFloatX4# = let x = x in x---- | Negate element-wise. --negateDoubleX2# :: DoubleX2# -> DoubleX2#-negateDoubleX2# = let x = x in x---- | Negate element-wise. --negateFloatX8# :: FloatX8# -> FloatX8#-negateFloatX8# = let x = x in x---- | Negate element-wise. --negateDoubleX4# :: DoubleX4# -> DoubleX4#-negateDoubleX4# = let x = x in x---- | Negate element-wise. --negateFloatX16# :: FloatX16# -> FloatX16#-negateFloatX16# = let x = x in x---- | Negate element-wise. --negateDoubleX8# :: DoubleX8# -> DoubleX8#-negateDoubleX8# = let x = x in x---- | Read a vector from specified index of immutable array. --indexInt8X16Array# :: ByteArray# -> Int# -> Int8X16#-indexInt8X16Array# = let x = x in x---- | Read a vector from specified index of immutable array. --indexInt16X8Array# :: ByteArray# -> Int# -> Int16X8#-indexInt16X8Array# = let x = x in x---- | Read a vector from specified index of immutable array. --indexInt32X4Array# :: ByteArray# -> Int# -> Int32X4#-indexInt32X4Array# = let x = x in x---- | Read a vector from specified index of immutable array. --indexInt64X2Array# :: ByteArray# -> Int# -> Int64X2#-indexInt64X2Array# = let x = x in x---- | Read a vector from specified index of immutable array. --indexInt8X32Array# :: ByteArray# -> Int# -> Int8X32#-indexInt8X32Array# = let x = x in x---- | Read a vector from specified index of immutable array. --indexInt16X16Array# :: ByteArray# -> Int# -> Int16X16#-indexInt16X16Array# = let x = x in x---- | Read a vector from specified index of immutable array. --indexInt32X8Array# :: ByteArray# -> Int# -> Int32X8#-indexInt32X8Array# = let x = x in x---- | Read a vector from specified index of immutable array. --indexInt64X4Array# :: ByteArray# -> Int# -> Int64X4#-indexInt64X4Array# = let x = x in x---- | Read a vector from specified index of immutable array. --indexInt8X64Array# :: ByteArray# -> Int# -> Int8X64#-indexInt8X64Array# = let x = x in x---- | Read a vector from specified index of immutable array. --indexInt16X32Array# :: ByteArray# -> Int# -> Int16X32#-indexInt16X32Array# = let x = x in x---- | Read a vector from specified index of immutable array. --indexInt32X16Array# :: ByteArray# -> Int# -> Int32X16#-indexInt32X16Array# = let x = x in x---- | Read a vector from specified index of immutable array. --indexInt64X8Array# :: ByteArray# -> Int# -> Int64X8#-indexInt64X8Array# = let x = x in x---- | Read a vector from specified index of immutable array. --indexWord8X16Array# :: ByteArray# -> Int# -> Word8X16#-indexWord8X16Array# = let x = x in x---- | Read a vector from specified index of immutable array. --indexWord16X8Array# :: ByteArray# -> Int# -> Word16X8#-indexWord16X8Array# = let x = x in x---- | Read a vector from specified index of immutable array. --indexWord32X4Array# :: ByteArray# -> Int# -> Word32X4#-indexWord32X4Array# = let x = x in x---- | Read a vector from specified index of immutable array. --indexWord64X2Array# :: ByteArray# -> Int# -> Word64X2#-indexWord64X2Array# = let x = x in x---- | Read a vector from specified index of immutable array. --indexWord8X32Array# :: ByteArray# -> Int# -> Word8X32#-indexWord8X32Array# = let x = x in x---- | Read a vector from specified index of immutable array. --indexWord16X16Array# :: ByteArray# -> Int# -> Word16X16#-indexWord16X16Array# = let x = x in x---- | Read a vector from specified index of immutable array. --indexWord32X8Array# :: ByteArray# -> Int# -> Word32X8#-indexWord32X8Array# = let x = x in x---- | Read a vector from specified index of immutable array. --indexWord64X4Array# :: ByteArray# -> Int# -> Word64X4#-indexWord64X4Array# = let x = x in x---- | Read a vector from specified index of immutable array. --indexWord8X64Array# :: ByteArray# -> Int# -> Word8X64#-indexWord8X64Array# = let x = x in x---- | Read a vector from specified index of immutable array. --indexWord16X32Array# :: ByteArray# -> Int# -> Word16X32#-indexWord16X32Array# = let x = x in x---- | Read a vector from specified index of immutable array. --indexWord32X16Array# :: ByteArray# -> Int# -> Word32X16#-indexWord32X16Array# = let x = x in x---- | Read a vector from specified index of immutable array. --indexWord64X8Array# :: ByteArray# -> Int# -> Word64X8#-indexWord64X8Array# = let x = x in x---- | Read a vector from specified index of immutable array. --indexFloatX4Array# :: ByteArray# -> Int# -> FloatX4#-indexFloatX4Array# = let x = x in x---- | Read a vector from specified index of immutable array. --indexDoubleX2Array# :: ByteArray# -> Int# -> DoubleX2#-indexDoubleX2Array# = let x = x in x---- | Read a vector from specified index of immutable array. --indexFloatX8Array# :: ByteArray# -> Int# -> FloatX8#-indexFloatX8Array# = let x = x in x---- | Read a vector from specified index of immutable array. --indexDoubleX4Array# :: ByteArray# -> Int# -> DoubleX4#-indexDoubleX4Array# = let x = x in x---- | Read a vector from specified index of immutable array. --indexFloatX16Array# :: ByteArray# -> Int# -> FloatX16#-indexFloatX16Array# = let x = x in x---- | Read a vector from specified index of immutable array. --indexDoubleX8Array# :: ByteArray# -> Int# -> DoubleX8#-indexDoubleX8Array# = let x = x in x---- | Read a vector from specified index of mutable array. --readInt8X16Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int8X16# #)-readInt8X16Array# = let x = x in x---- | Read a vector from specified index of mutable array. --readInt16X8Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int16X8# #)-readInt16X8Array# = let x = x in x---- | Read a vector from specified index of mutable array. --readInt32X4Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int32X4# #)-readInt32X4Array# = let x = x in x---- | Read a vector from specified index of mutable array. --readInt64X2Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int64X2# #)-readInt64X2Array# = let x = x in x---- | Read a vector from specified index of mutable array. --readInt8X32Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int8X32# #)-readInt8X32Array# = let x = x in x---- | Read a vector from specified index of mutable array. --readInt16X16Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int16X16# #)-readInt16X16Array# = let x = x in x---- | Read a vector from specified index of mutable array. --readInt32X8Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int32X8# #)-readInt32X8Array# = let x = x in x---- | Read a vector from specified index of mutable array. --readInt64X4Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int64X4# #)-readInt64X4Array# = let x = x in x---- | Read a vector from specified index of mutable array. --readInt8X64Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int8X64# #)-readInt8X64Array# = let x = x in x---- | Read a vector from specified index of mutable array. --readInt16X32Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int16X32# #)-readInt16X32Array# = let x = x in x---- | Read a vector from specified index of mutable array. --readInt32X16Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int32X16# #)-readInt32X16Array# = let x = x in x---- | Read a vector from specified index of mutable array. --readInt64X8Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int64X8# #)-readInt64X8Array# = let x = x in x---- | Read a vector from specified index of mutable array. --readWord8X16Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word8X16# #)-readWord8X16Array# = let x = x in x---- | Read a vector from specified index of mutable array. --readWord16X8Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word16X8# #)-readWord16X8Array# = let x = x in x---- | Read a vector from specified index of mutable array. --readWord32X4Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word32X4# #)-readWord32X4Array# = let x = x in x---- | Read a vector from specified index of mutable array. --readWord64X2Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word64X2# #)-readWord64X2Array# = let x = x in x---- | Read a vector from specified index of mutable array. --readWord8X32Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word8X32# #)-readWord8X32Array# = let x = x in x---- | Read a vector from specified index of mutable array. --readWord16X16Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word16X16# #)-readWord16X16Array# = let x = x in x---- | Read a vector from specified index of mutable array. --readWord32X8Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word32X8# #)-readWord32X8Array# = let x = x in x---- | Read a vector from specified index of mutable array. --readWord64X4Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word64X4# #)-readWord64X4Array# = let x = x in x---- | Read a vector from specified index of mutable array. --readWord8X64Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word8X64# #)-readWord8X64Array# = let x = x in x---- | Read a vector from specified index of mutable array. --readWord16X32Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word16X32# #)-readWord16X32Array# = let x = x in x---- | Read a vector from specified index of mutable array. --readWord32X16Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word32X16# #)-readWord32X16Array# = let x = x in x---- | Read a vector from specified index of mutable array. --readWord64X8Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word64X8# #)-readWord64X8Array# = let x = x in x---- | Read a vector from specified index of mutable array. --readFloatX4Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,FloatX4# #)-readFloatX4Array# = let x = x in x---- | Read a vector from specified index of mutable array. --readDoubleX2Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,DoubleX2# #)-readDoubleX2Array# = let x = x in x---- | Read a vector from specified index of mutable array. --readFloatX8Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,FloatX8# #)-readFloatX8Array# = let x = x in x---- | Read a vector from specified index of mutable array. --readDoubleX4Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,DoubleX4# #)-readDoubleX4Array# = let x = x in x---- | Read a vector from specified index of mutable array. --readFloatX16Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,FloatX16# #)-readFloatX16Array# = let x = x in x---- | Read a vector from specified index of mutable array. --readDoubleX8Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,DoubleX8# #)-readDoubleX8Array# = let x = x in x---- | Write a vector to specified index of mutable array. --writeInt8X16Array# :: MutableByteArray# s -> Int# -> Int8X16# -> State# s -> State# s-writeInt8X16Array# = let x = x in x---- | Write a vector to specified index of mutable array. --writeInt16X8Array# :: MutableByteArray# s -> Int# -> Int16X8# -> State# s -> State# s-writeInt16X8Array# = let x = x in x---- | Write a vector to specified index of mutable array. --writeInt32X4Array# :: MutableByteArray# s -> Int# -> Int32X4# -> State# s -> State# s-writeInt32X4Array# = let x = x in x---- | Write a vector to specified index of mutable array. --writeInt64X2Array# :: MutableByteArray# s -> Int# -> Int64X2# -> State# s -> State# s-writeInt64X2Array# = let x = x in x---- | Write a vector to specified index of mutable array. --writeInt8X32Array# :: MutableByteArray# s -> Int# -> Int8X32# -> State# s -> State# s-writeInt8X32Array# = let x = x in x---- | Write a vector to specified index of mutable array. --writeInt16X16Array# :: MutableByteArray# s -> Int# -> Int16X16# -> State# s -> State# s-writeInt16X16Array# = let x = x in x---- | Write a vector to specified index of mutable array. --writeInt32X8Array# :: MutableByteArray# s -> Int# -> Int32X8# -> State# s -> State# s-writeInt32X8Array# = let x = x in x---- | Write a vector to specified index of mutable array. --writeInt64X4Array# :: MutableByteArray# s -> Int# -> Int64X4# -> State# s -> State# s-writeInt64X4Array# = let x = x in x---- | Write a vector to specified index of mutable array. --writeInt8X64Array# :: MutableByteArray# s -> Int# -> Int8X64# -> State# s -> State# s-writeInt8X64Array# = let x = x in x---- | Write a vector to specified index of mutable array. --writeInt16X32Array# :: MutableByteArray# s -> Int# -> Int16X32# -> State# s -> State# s-writeInt16X32Array# = let x = x in x---- | Write a vector to specified index of mutable array. --writeInt32X16Array# :: MutableByteArray# s -> Int# -> Int32X16# -> State# s -> State# s-writeInt32X16Array# = let x = x in x---- | Write a vector to specified index of mutable array. --writeInt64X8Array# :: MutableByteArray# s -> Int# -> Int64X8# -> State# s -> State# s-writeInt64X8Array# = let x = x in x---- | Write a vector to specified index of mutable array. --writeWord8X16Array# :: MutableByteArray# s -> Int# -> Word8X16# -> State# s -> State# s-writeWord8X16Array# = let x = x in x---- | Write a vector to specified index of mutable array. --writeWord16X8Array# :: MutableByteArray# s -> Int# -> Word16X8# -> State# s -> State# s-writeWord16X8Array# = let x = x in x---- | Write a vector to specified index of mutable array. --writeWord32X4Array# :: MutableByteArray# s -> Int# -> Word32X4# -> State# s -> State# s-writeWord32X4Array# = let x = x in x---- | Write a vector to specified index of mutable array. --writeWord64X2Array# :: MutableByteArray# s -> Int# -> Word64X2# -> State# s -> State# s-writeWord64X2Array# = let x = x in x---- | Write a vector to specified index of mutable array. --writeWord8X32Array# :: MutableByteArray# s -> Int# -> Word8X32# -> State# s -> State# s-writeWord8X32Array# = let x = x in x---- | Write a vector to specified index of mutable array. --writeWord16X16Array# :: MutableByteArray# s -> Int# -> Word16X16# -> State# s -> State# s-writeWord16X16Array# = let x = x in x---- | Write a vector to specified index of mutable array. --writeWord32X8Array# :: MutableByteArray# s -> Int# -> Word32X8# -> State# s -> State# s-writeWord32X8Array# = let x = x in x---- | Write a vector to specified index of mutable array. --writeWord64X4Array# :: MutableByteArray# s -> Int# -> Word64X4# -> State# s -> State# s-writeWord64X4Array# = let x = x in x---- | Write a vector to specified index of mutable array. --writeWord8X64Array# :: MutableByteArray# s -> Int# -> Word8X64# -> State# s -> State# s-writeWord8X64Array# = let x = x in x---- | Write a vector to specified index of mutable array. --writeWord16X32Array# :: MutableByteArray# s -> Int# -> Word16X32# -> State# s -> State# s-writeWord16X32Array# = let x = x in x---- | Write a vector to specified index of mutable array. --writeWord32X16Array# :: MutableByteArray# s -> Int# -> Word32X16# -> State# s -> State# s-writeWord32X16Array# = let x = x in x---- | Write a vector to specified index of mutable array. --writeWord64X8Array# :: MutableByteArray# s -> Int# -> Word64X8# -> State# s -> State# s-writeWord64X8Array# = let x = x in x---- | Write a vector to specified index of mutable array. --writeFloatX4Array# :: MutableByteArray# s -> Int# -> FloatX4# -> State# s -> State# s-writeFloatX4Array# = let x = x in x---- | Write a vector to specified index of mutable array. --writeDoubleX2Array# :: MutableByteArray# s -> Int# -> DoubleX2# -> State# s -> State# s-writeDoubleX2Array# = let x = x in x---- | Write a vector to specified index of mutable array. --writeFloatX8Array# :: MutableByteArray# s -> Int# -> FloatX8# -> State# s -> State# s-writeFloatX8Array# = let x = x in x---- | Write a vector to specified index of mutable array. --writeDoubleX4Array# :: MutableByteArray# s -> Int# -> DoubleX4# -> State# s -> State# s-writeDoubleX4Array# = let x = x in x---- | Write a vector to specified index of mutable array. --writeFloatX16Array# :: MutableByteArray# s -> Int# -> FloatX16# -> State# s -> State# s-writeFloatX16Array# = let x = x in x---- | Write a vector to specified index of mutable array. --writeDoubleX8Array# :: MutableByteArray# s -> Int# -> DoubleX8# -> State# s -> State# s-writeDoubleX8Array# = let x = x in x---- | Reads vector; offset in bytes. --indexInt8X16OffAddr# :: Addr# -> Int# -> Int8X16#-indexInt8X16OffAddr# = let x = x in x---- | Reads vector; offset in bytes. --indexInt16X8OffAddr# :: Addr# -> Int# -> Int16X8#-indexInt16X8OffAddr# = let x = x in x---- | Reads vector; offset in bytes. --indexInt32X4OffAddr# :: Addr# -> Int# -> Int32X4#-indexInt32X4OffAddr# = let x = x in x---- | Reads vector; offset in bytes. --indexInt64X2OffAddr# :: Addr# -> Int# -> Int64X2#-indexInt64X2OffAddr# = let x = x in x---- | Reads vector; offset in bytes. --indexInt8X32OffAddr# :: Addr# -> Int# -> Int8X32#-indexInt8X32OffAddr# = let x = x in x---- | Reads vector; offset in bytes. --indexInt16X16OffAddr# :: Addr# -> Int# -> Int16X16#-indexInt16X16OffAddr# = let x = x in x---- | Reads vector; offset in bytes. --indexInt32X8OffAddr# :: Addr# -> Int# -> Int32X8#-indexInt32X8OffAddr# = let x = x in x---- | Reads vector; offset in bytes. --indexInt64X4OffAddr# :: Addr# -> Int# -> Int64X4#-indexInt64X4OffAddr# = let x = x in x---- | Reads vector; offset in bytes. --indexInt8X64OffAddr# :: Addr# -> Int# -> Int8X64#-indexInt8X64OffAddr# = let x = x in x---- | Reads vector; offset in bytes. --indexInt16X32OffAddr# :: Addr# -> Int# -> Int16X32#-indexInt16X32OffAddr# = let x = x in x---- | Reads vector; offset in bytes. --indexInt32X16OffAddr# :: Addr# -> Int# -> Int32X16#-indexInt32X16OffAddr# = let x = x in x---- | Reads vector; offset in bytes. --indexInt64X8OffAddr# :: Addr# -> Int# -> Int64X8#-indexInt64X8OffAddr# = let x = x in x---- | Reads vector; offset in bytes. --indexWord8X16OffAddr# :: Addr# -> Int# -> Word8X16#-indexWord8X16OffAddr# = let x = x in x---- | Reads vector; offset in bytes. --indexWord16X8OffAddr# :: Addr# -> Int# -> Word16X8#-indexWord16X8OffAddr# = let x = x in x---- | Reads vector; offset in bytes. --indexWord32X4OffAddr# :: Addr# -> Int# -> Word32X4#-indexWord32X4OffAddr# = let x = x in x---- | Reads vector; offset in bytes. --indexWord64X2OffAddr# :: Addr# -> Int# -> Word64X2#-indexWord64X2OffAddr# = let x = x in x---- | Reads vector; offset in bytes. --indexWord8X32OffAddr# :: Addr# -> Int# -> Word8X32#-indexWord8X32OffAddr# = let x = x in x---- | Reads vector; offset in bytes. --indexWord16X16OffAddr# :: Addr# -> Int# -> Word16X16#-indexWord16X16OffAddr# = let x = x in x---- | Reads vector; offset in bytes. --indexWord32X8OffAddr# :: Addr# -> Int# -> Word32X8#-indexWord32X8OffAddr# = let x = x in x---- | Reads vector; offset in bytes. --indexWord64X4OffAddr# :: Addr# -> Int# -> Word64X4#-indexWord64X4OffAddr# = let x = x in x---- | Reads vector; offset in bytes. --indexWord8X64OffAddr# :: Addr# -> Int# -> Word8X64#-indexWord8X64OffAddr# = let x = x in x---- | Reads vector; offset in bytes. --indexWord16X32OffAddr# :: Addr# -> Int# -> Word16X32#-indexWord16X32OffAddr# = let x = x in x---- | Reads vector; offset in bytes. --indexWord32X16OffAddr# :: Addr# -> Int# -> Word32X16#-indexWord32X16OffAddr# = let x = x in x---- | Reads vector; offset in bytes. --indexWord64X8OffAddr# :: Addr# -> Int# -> Word64X8#-indexWord64X8OffAddr# = let x = x in x---- | Reads vector; offset in bytes. --indexFloatX4OffAddr# :: Addr# -> Int# -> FloatX4#-indexFloatX4OffAddr# = let x = x in x---- | Reads vector; offset in bytes. --indexDoubleX2OffAddr# :: Addr# -> Int# -> DoubleX2#-indexDoubleX2OffAddr# = let x = x in x---- | Reads vector; offset in bytes. --indexFloatX8OffAddr# :: Addr# -> Int# -> FloatX8#-indexFloatX8OffAddr# = let x = x in x---- | Reads vector; offset in bytes. --indexDoubleX4OffAddr# :: Addr# -> Int# -> DoubleX4#-indexDoubleX4OffAddr# = let x = x in x---- | Reads vector; offset in bytes. --indexFloatX16OffAddr# :: Addr# -> Int# -> FloatX16#-indexFloatX16OffAddr# = let x = x in x---- | Reads vector; offset in bytes. --indexDoubleX8OffAddr# :: Addr# -> Int# -> DoubleX8#-indexDoubleX8OffAddr# = let x = x in x---- | Reads vector; offset in bytes. --readInt8X16OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int8X16# #)-readInt8X16OffAddr# = let x = x in x---- | Reads vector; offset in bytes. --readInt16X8OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int16X8# #)-readInt16X8OffAddr# = let x = x in x---- | Reads vector; offset in bytes. --readInt32X4OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int32X4# #)-readInt32X4OffAddr# = let x = x in x---- | Reads vector; offset in bytes. --readInt64X2OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int64X2# #)-readInt64X2OffAddr# = let x = x in x---- | Reads vector; offset in bytes. --readInt8X32OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int8X32# #)-readInt8X32OffAddr# = let x = x in x---- | Reads vector; offset in bytes. --readInt16X16OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int16X16# #)-readInt16X16OffAddr# = let x = x in x---- | Reads vector; offset in bytes. --readInt32X8OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int32X8# #)-readInt32X8OffAddr# = let x = x in x---- | Reads vector; offset in bytes. --readInt64X4OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int64X4# #)-readInt64X4OffAddr# = let x = x in x---- | Reads vector; offset in bytes. --readInt8X64OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int8X64# #)-readInt8X64OffAddr# = let x = x in x---- | Reads vector; offset in bytes. --readInt16X32OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int16X32# #)-readInt16X32OffAddr# = let x = x in x---- | Reads vector; offset in bytes. --readInt32X16OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int32X16# #)-readInt32X16OffAddr# = let x = x in x---- | Reads vector; offset in bytes. --readInt64X8OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int64X8# #)-readInt64X8OffAddr# = let x = x in x---- | Reads vector; offset in bytes. --readWord8X16OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word8X16# #)-readWord8X16OffAddr# = let x = x in x---- | Reads vector; offset in bytes. --readWord16X8OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word16X8# #)-readWord16X8OffAddr# = let x = x in x---- | Reads vector; offset in bytes. --readWord32X4OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word32X4# #)-readWord32X4OffAddr# = let x = x in x---- | Reads vector; offset in bytes. --readWord64X2OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word64X2# #)-readWord64X2OffAddr# = let x = x in x---- | Reads vector; offset in bytes. --readWord8X32OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word8X32# #)-readWord8X32OffAddr# = let x = x in x---- | Reads vector; offset in bytes. --readWord16X16OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word16X16# #)-readWord16X16OffAddr# = let x = x in x---- | Reads vector; offset in bytes. --readWord32X8OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word32X8# #)-readWord32X8OffAddr# = let x = x in x---- | Reads vector; offset in bytes. --readWord64X4OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word64X4# #)-readWord64X4OffAddr# = let x = x in x---- | Reads vector; offset in bytes. --readWord8X64OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word8X64# #)-readWord8X64OffAddr# = let x = x in x---- | Reads vector; offset in bytes. --readWord16X32OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word16X32# #)-readWord16X32OffAddr# = let x = x in x---- | Reads vector; offset in bytes. --readWord32X16OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word32X16# #)-readWord32X16OffAddr# = let x = x in x---- | Reads vector; offset in bytes. --readWord64X8OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word64X8# #)-readWord64X8OffAddr# = let x = x in x---- | Reads vector; offset in bytes. --readFloatX4OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,FloatX4# #)-readFloatX4OffAddr# = let x = x in x---- | Reads vector; offset in bytes. --readDoubleX2OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,DoubleX2# #)-readDoubleX2OffAddr# = let x = x in x---- | Reads vector; offset in bytes. --readFloatX8OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,FloatX8# #)-readFloatX8OffAddr# = let x = x in x---- | Reads vector; offset in bytes. --readDoubleX4OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,DoubleX4# #)-readDoubleX4OffAddr# = let x = x in x---- | Reads vector; offset in bytes. --readFloatX16OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,FloatX16# #)-readFloatX16OffAddr# = let x = x in x---- | Reads vector; offset in bytes. --readDoubleX8OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,DoubleX8# #)-readDoubleX8OffAddr# = let x = x in x---- | Write vector; offset in bytes. --writeInt8X16OffAddr# :: Addr# -> Int# -> Int8X16# -> State# s -> State# s-writeInt8X16OffAddr# = let x = x in x---- | Write vector; offset in bytes. --writeInt16X8OffAddr# :: Addr# -> Int# -> Int16X8# -> State# s -> State# s-writeInt16X8OffAddr# = let x = x in x---- | Write vector; offset in bytes. --writeInt32X4OffAddr# :: Addr# -> Int# -> Int32X4# -> State# s -> State# s-writeInt32X4OffAddr# = let x = x in x---- | Write vector; offset in bytes. --writeInt64X2OffAddr# :: Addr# -> Int# -> Int64X2# -> State# s -> State# s-writeInt64X2OffAddr# = let x = x in x---- | Write vector; offset in bytes. --writeInt8X32OffAddr# :: Addr# -> Int# -> Int8X32# -> State# s -> State# s-writeInt8X32OffAddr# = let x = x in x---- | Write vector; offset in bytes. --writeInt16X16OffAddr# :: Addr# -> Int# -> Int16X16# -> State# s -> State# s-writeInt16X16OffAddr# = let x = x in x---- | Write vector; offset in bytes. --writeInt32X8OffAddr# :: Addr# -> Int# -> Int32X8# -> State# s -> State# s-writeInt32X8OffAddr# = let x = x in x---- | Write vector; offset in bytes. --writeInt64X4OffAddr# :: Addr# -> Int# -> Int64X4# -> State# s -> State# s-writeInt64X4OffAddr# = let x = x in x---- | Write vector; offset in bytes. --writeInt8X64OffAddr# :: Addr# -> Int# -> Int8X64# -> State# s -> State# s-writeInt8X64OffAddr# = let x = x in x---- | Write vector; offset in bytes. --writeInt16X32OffAddr# :: Addr# -> Int# -> Int16X32# -> State# s -> State# s-writeInt16X32OffAddr# = let x = x in x---- | Write vector; offset in bytes. --writeInt32X16OffAddr# :: Addr# -> Int# -> Int32X16# -> State# s -> State# s-writeInt32X16OffAddr# = let x = x in x---- | Write vector; offset in bytes. --writeInt64X8OffAddr# :: Addr# -> Int# -> Int64X8# -> State# s -> State# s-writeInt64X8OffAddr# = let x = x in x---- | Write vector; offset in bytes. --writeWord8X16OffAddr# :: Addr# -> Int# -> Word8X16# -> State# s -> State# s-writeWord8X16OffAddr# = let x = x in x---- | Write vector; offset in bytes. --writeWord16X8OffAddr# :: Addr# -> Int# -> Word16X8# -> State# s -> State# s-writeWord16X8OffAddr# = let x = x in x---- | Write vector; offset in bytes. --writeWord32X4OffAddr# :: Addr# -> Int# -> Word32X4# -> State# s -> State# s-writeWord32X4OffAddr# = let x = x in x---- | Write vector; offset in bytes. --writeWord64X2OffAddr# :: Addr# -> Int# -> Word64X2# -> State# s -> State# s-writeWord64X2OffAddr# = let x = x in x---- | Write vector; offset in bytes. --writeWord8X32OffAddr# :: Addr# -> Int# -> Word8X32# -> State# s -> State# s-writeWord8X32OffAddr# = let x = x in x---- | Write vector; offset in bytes. --writeWord16X16OffAddr# :: Addr# -> Int# -> Word16X16# -> State# s -> State# s-writeWord16X16OffAddr# = let x = x in x---- | Write vector; offset in bytes. --writeWord32X8OffAddr# :: Addr# -> Int# -> Word32X8# -> State# s -> State# s-writeWord32X8OffAddr# = let x = x in x---- | Write vector; offset in bytes. --writeWord64X4OffAddr# :: Addr# -> Int# -> Word64X4# -> State# s -> State# s-writeWord64X4OffAddr# = let x = x in x---- | Write vector; offset in bytes. --writeWord8X64OffAddr# :: Addr# -> Int# -> Word8X64# -> State# s -> State# s-writeWord8X64OffAddr# = let x = x in x---- | Write vector; offset in bytes. --writeWord16X32OffAddr# :: Addr# -> Int# -> Word16X32# -> State# s -> State# s-writeWord16X32OffAddr# = let x = x in x---- | Write vector; offset in bytes. --writeWord32X16OffAddr# :: Addr# -> Int# -> Word32X16# -> State# s -> State# s-writeWord32X16OffAddr# = let x = x in x---- | Write vector; offset in bytes. --writeWord64X8OffAddr# :: Addr# -> Int# -> Word64X8# -> State# s -> State# s-writeWord64X8OffAddr# = let x = x in x---- | Write vector; offset in bytes. --writeFloatX4OffAddr# :: Addr# -> Int# -> FloatX4# -> State# s -> State# s-writeFloatX4OffAddr# = let x = x in x---- | Write vector; offset in bytes. --writeDoubleX2OffAddr# :: Addr# -> Int# -> DoubleX2# -> State# s -> State# s-writeDoubleX2OffAddr# = let x = x in x---- | Write vector; offset in bytes. --writeFloatX8OffAddr# :: Addr# -> Int# -> FloatX8# -> State# s -> State# s-writeFloatX8OffAddr# = let x = x in x---- | Write vector; offset in bytes. --writeDoubleX4OffAddr# :: Addr# -> Int# -> DoubleX4# -> State# s -> State# s-writeDoubleX4OffAddr# = let x = x in x---- | Write vector; offset in bytes. --writeFloatX16OffAddr# :: Addr# -> Int# -> FloatX16# -> State# s -> State# s-writeFloatX16OffAddr# = let x = x in x---- | Write vector; offset in bytes. --writeDoubleX8OffAddr# :: Addr# -> Int# -> DoubleX8# -> State# s -> State# s-writeDoubleX8OffAddr# = let x = x in x---- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. --indexInt8ArrayAsInt8X16# :: ByteArray# -> Int# -> Int8X16#-indexInt8ArrayAsInt8X16# = let x = x in x---- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. --indexInt16ArrayAsInt16X8# :: ByteArray# -> Int# -> Int16X8#-indexInt16ArrayAsInt16X8# = let x = x in x---- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. --indexInt32ArrayAsInt32X4# :: ByteArray# -> Int# -> Int32X4#-indexInt32ArrayAsInt32X4# = let x = x in x---- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. --indexInt64ArrayAsInt64X2# :: ByteArray# -> Int# -> Int64X2#-indexInt64ArrayAsInt64X2# = let x = x in x---- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. --indexInt8ArrayAsInt8X32# :: ByteArray# -> Int# -> Int8X32#-indexInt8ArrayAsInt8X32# = let x = x in x---- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. --indexInt16ArrayAsInt16X16# :: ByteArray# -> Int# -> Int16X16#-indexInt16ArrayAsInt16X16# = let x = x in x---- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. --indexInt32ArrayAsInt32X8# :: ByteArray# -> Int# -> Int32X8#-indexInt32ArrayAsInt32X8# = let x = x in x---- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. --indexInt64ArrayAsInt64X4# :: ByteArray# -> Int# -> Int64X4#-indexInt64ArrayAsInt64X4# = let x = x in x---- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. --indexInt8ArrayAsInt8X64# :: ByteArray# -> Int# -> Int8X64#-indexInt8ArrayAsInt8X64# = let x = x in x---- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. --indexInt16ArrayAsInt16X32# :: ByteArray# -> Int# -> Int16X32#-indexInt16ArrayAsInt16X32# = let x = x in x---- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. --indexInt32ArrayAsInt32X16# :: ByteArray# -> Int# -> Int32X16#-indexInt32ArrayAsInt32X16# = let x = x in x---- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. --indexInt64ArrayAsInt64X8# :: ByteArray# -> Int# -> Int64X8#-indexInt64ArrayAsInt64X8# = let x = x in x---- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. --indexWord8ArrayAsWord8X16# :: ByteArray# -> Int# -> Word8X16#-indexWord8ArrayAsWord8X16# = let x = x in x---- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. --indexWord16ArrayAsWord16X8# :: ByteArray# -> Int# -> Word16X8#-indexWord16ArrayAsWord16X8# = let x = x in x---- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. --indexWord32ArrayAsWord32X4# :: ByteArray# -> Int# -> Word32X4#-indexWord32ArrayAsWord32X4# = let x = x in x---- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. --indexWord64ArrayAsWord64X2# :: ByteArray# -> Int# -> Word64X2#-indexWord64ArrayAsWord64X2# = let x = x in x---- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. --indexWord8ArrayAsWord8X32# :: ByteArray# -> Int# -> Word8X32#-indexWord8ArrayAsWord8X32# = let x = x in x---- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. --indexWord16ArrayAsWord16X16# :: ByteArray# -> Int# -> Word16X16#-indexWord16ArrayAsWord16X16# = let x = x in x---- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. --indexWord32ArrayAsWord32X8# :: ByteArray# -> Int# -> Word32X8#-indexWord32ArrayAsWord32X8# = let x = x in x---- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. --indexWord64ArrayAsWord64X4# :: ByteArray# -> Int# -> Word64X4#-indexWord64ArrayAsWord64X4# = let x = x in x---- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. --indexWord8ArrayAsWord8X64# :: ByteArray# -> Int# -> Word8X64#-indexWord8ArrayAsWord8X64# = let x = x in x---- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. --indexWord16ArrayAsWord16X32# :: ByteArray# -> Int# -> Word16X32#-indexWord16ArrayAsWord16X32# = let x = x in x---- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. --indexWord32ArrayAsWord32X16# :: ByteArray# -> Int# -> Word32X16#-indexWord32ArrayAsWord32X16# = let x = x in x---- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. --indexWord64ArrayAsWord64X8# :: ByteArray# -> Int# -> Word64X8#-indexWord64ArrayAsWord64X8# = let x = x in x---- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. --indexFloatArrayAsFloatX4# :: ByteArray# -> Int# -> FloatX4#-indexFloatArrayAsFloatX4# = let x = x in x---- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. --indexDoubleArrayAsDoubleX2# :: ByteArray# -> Int# -> DoubleX2#-indexDoubleArrayAsDoubleX2# = let x = x in x---- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. --indexFloatArrayAsFloatX8# :: ByteArray# -> Int# -> FloatX8#-indexFloatArrayAsFloatX8# = let x = x in x---- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. --indexDoubleArrayAsDoubleX4# :: ByteArray# -> Int# -> DoubleX4#-indexDoubleArrayAsDoubleX4# = let x = x in x---- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. --indexFloatArrayAsFloatX16# :: ByteArray# -> Int# -> FloatX16#-indexFloatArrayAsFloatX16# = let x = x in x---- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. --indexDoubleArrayAsDoubleX8# :: ByteArray# -> Int# -> DoubleX8#-indexDoubleArrayAsDoubleX8# = let x = x in x---- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. --readInt8ArrayAsInt8X16# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int8X16# #)-readInt8ArrayAsInt8X16# = let x = x in x---- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. --readInt16ArrayAsInt16X8# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int16X8# #)-readInt16ArrayAsInt16X8# = let x = x in x---- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. --readInt32ArrayAsInt32X4# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int32X4# #)-readInt32ArrayAsInt32X4# = let x = x in x---- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. --readInt64ArrayAsInt64X2# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int64X2# #)-readInt64ArrayAsInt64X2# = let x = x in x---- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. --readInt8ArrayAsInt8X32# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int8X32# #)-readInt8ArrayAsInt8X32# = let x = x in x---- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. --readInt16ArrayAsInt16X16# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int16X16# #)-readInt16ArrayAsInt16X16# = let x = x in x---- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. --readInt32ArrayAsInt32X8# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int32X8# #)-readInt32ArrayAsInt32X8# = let x = x in x---- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. --readInt64ArrayAsInt64X4# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int64X4# #)-readInt64ArrayAsInt64X4# = let x = x in x---- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. --readInt8ArrayAsInt8X64# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int8X64# #)-readInt8ArrayAsInt8X64# = let x = x in x---- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. --readInt16ArrayAsInt16X32# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int16X32# #)-readInt16ArrayAsInt16X32# = let x = x in x---- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. --readInt32ArrayAsInt32X16# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int32X16# #)-readInt32ArrayAsInt32X16# = let x = x in x---- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. --readInt64ArrayAsInt64X8# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int64X8# #)-readInt64ArrayAsInt64X8# = let x = x in x---- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. --readWord8ArrayAsWord8X16# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word8X16# #)-readWord8ArrayAsWord8X16# = let x = x in x---- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. --readWord16ArrayAsWord16X8# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word16X8# #)-readWord16ArrayAsWord16X8# = let x = x in x---- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. --readWord32ArrayAsWord32X4# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word32X4# #)-readWord32ArrayAsWord32X4# = let x = x in x---- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. --readWord64ArrayAsWord64X2# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word64X2# #)-readWord64ArrayAsWord64X2# = let x = x in x---- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. --readWord8ArrayAsWord8X32# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word8X32# #)-readWord8ArrayAsWord8X32# = let x = x in x---- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. --readWord16ArrayAsWord16X16# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word16X16# #)-readWord16ArrayAsWord16X16# = let x = x in x---- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. --readWord32ArrayAsWord32X8# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word32X8# #)-readWord32ArrayAsWord32X8# = let x = x in x---- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. --readWord64ArrayAsWord64X4# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word64X4# #)-readWord64ArrayAsWord64X4# = let x = x in x---- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. --readWord8ArrayAsWord8X64# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word8X64# #)-readWord8ArrayAsWord8X64# = let x = x in x---- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. --readWord16ArrayAsWord16X32# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word16X32# #)-readWord16ArrayAsWord16X32# = let x = x in x---- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. --readWord32ArrayAsWord32X16# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word32X16# #)-readWord32ArrayAsWord32X16# = let x = x in x---- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. --readWord64ArrayAsWord64X8# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word64X8# #)-readWord64ArrayAsWord64X8# = let x = x in x---- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. --readFloatArrayAsFloatX4# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,FloatX4# #)-readFloatArrayAsFloatX4# = let x = x in x---- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. --readDoubleArrayAsDoubleX2# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,DoubleX2# #)-readDoubleArrayAsDoubleX2# = let x = x in x---- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. --readFloatArrayAsFloatX8# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,FloatX8# #)-readFloatArrayAsFloatX8# = let x = x in x---- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. --readDoubleArrayAsDoubleX4# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,DoubleX4# #)-readDoubleArrayAsDoubleX4# = let x = x in x---- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. --readFloatArrayAsFloatX16# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,FloatX16# #)-readFloatArrayAsFloatX16# = let x = x in x---- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. --readDoubleArrayAsDoubleX8# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,DoubleX8# #)-readDoubleArrayAsDoubleX8# = let x = x in x---- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. --writeInt8ArrayAsInt8X16# :: MutableByteArray# s -> Int# -> Int8X16# -> State# s -> State# s-writeInt8ArrayAsInt8X16# = let x = x in x---- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. --writeInt16ArrayAsInt16X8# :: MutableByteArray# s -> Int# -> Int16X8# -> State# s -> State# s-writeInt16ArrayAsInt16X8# = let x = x in x---- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. --writeInt32ArrayAsInt32X4# :: MutableByteArray# s -> Int# -> Int32X4# -> State# s -> State# s-writeInt32ArrayAsInt32X4# = let x = x in x---- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. --writeInt64ArrayAsInt64X2# :: MutableByteArray# s -> Int# -> Int64X2# -> State# s -> State# s-writeInt64ArrayAsInt64X2# = let x = x in x---- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. --writeInt8ArrayAsInt8X32# :: MutableByteArray# s -> Int# -> Int8X32# -> State# s -> State# s-writeInt8ArrayAsInt8X32# = let x = x in x---- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. --writeInt16ArrayAsInt16X16# :: MutableByteArray# s -> Int# -> Int16X16# -> State# s -> State# s-writeInt16ArrayAsInt16X16# = let x = x in x---- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. --writeInt32ArrayAsInt32X8# :: MutableByteArray# s -> Int# -> Int32X8# -> State# s -> State# s-writeInt32ArrayAsInt32X8# = let x = x in x---- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. --writeInt64ArrayAsInt64X4# :: MutableByteArray# s -> Int# -> Int64X4# -> State# s -> State# s-writeInt64ArrayAsInt64X4# = let x = x in x---- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. --writeInt8ArrayAsInt8X64# :: MutableByteArray# s -> Int# -> Int8X64# -> State# s -> State# s-writeInt8ArrayAsInt8X64# = let x = x in x---- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. --writeInt16ArrayAsInt16X32# :: MutableByteArray# s -> Int# -> Int16X32# -> State# s -> State# s-writeInt16ArrayAsInt16X32# = let x = x in x---- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. --writeInt32ArrayAsInt32X16# :: MutableByteArray# s -> Int# -> Int32X16# -> State# s -> State# s-writeInt32ArrayAsInt32X16# = let x = x in x---- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. --writeInt64ArrayAsInt64X8# :: MutableByteArray# s -> Int# -> Int64X8# -> State# s -> State# s-writeInt64ArrayAsInt64X8# = let x = x in x---- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. --writeWord8ArrayAsWord8X16# :: MutableByteArray# s -> Int# -> Word8X16# -> State# s -> State# s-writeWord8ArrayAsWord8X16# = let x = x in x---- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. --writeWord16ArrayAsWord16X8# :: MutableByteArray# s -> Int# -> Word16X8# -> State# s -> State# s-writeWord16ArrayAsWord16X8# = let x = x in x---- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. --writeWord32ArrayAsWord32X4# :: MutableByteArray# s -> Int# -> Word32X4# -> State# s -> State# s-writeWord32ArrayAsWord32X4# = let x = x in x---- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. --writeWord64ArrayAsWord64X2# :: MutableByteArray# s -> Int# -> Word64X2# -> State# s -> State# s-writeWord64ArrayAsWord64X2# = let x = x in x---- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. --writeWord8ArrayAsWord8X32# :: MutableByteArray# s -> Int# -> Word8X32# -> State# s -> State# s-writeWord8ArrayAsWord8X32# = let x = x in x---- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. --writeWord16ArrayAsWord16X16# :: MutableByteArray# s -> Int# -> Word16X16# -> State# s -> State# s-writeWord16ArrayAsWord16X16# = let x = x in x---- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. --writeWord32ArrayAsWord32X8# :: MutableByteArray# s -> Int# -> Word32X8# -> State# s -> State# s-writeWord32ArrayAsWord32X8# = let x = x in x---- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. --writeWord64ArrayAsWord64X4# :: MutableByteArray# s -> Int# -> Word64X4# -> State# s -> State# s-writeWord64ArrayAsWord64X4# = let x = x in x---- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. --writeWord8ArrayAsWord8X64# :: MutableByteArray# s -> Int# -> Word8X64# -> State# s -> State# s-writeWord8ArrayAsWord8X64# = let x = x in x---- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. --writeWord16ArrayAsWord16X32# :: MutableByteArray# s -> Int# -> Word16X32# -> State# s -> State# s-writeWord16ArrayAsWord16X32# = let x = x in x---- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. --writeWord32ArrayAsWord32X16# :: MutableByteArray# s -> Int# -> Word32X16# -> State# s -> State# s-writeWord32ArrayAsWord32X16# = let x = x in x---- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. --writeWord64ArrayAsWord64X8# :: MutableByteArray# s -> Int# -> Word64X8# -> State# s -> State# s-writeWord64ArrayAsWord64X8# = let x = x in x---- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. --writeFloatArrayAsFloatX4# :: MutableByteArray# s -> Int# -> FloatX4# -> State# s -> State# s-writeFloatArrayAsFloatX4# = let x = x in x---- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. --writeDoubleArrayAsDoubleX2# :: MutableByteArray# s -> Int# -> DoubleX2# -> State# s -> State# s-writeDoubleArrayAsDoubleX2# = let x = x in x---- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. --writeFloatArrayAsFloatX8# :: MutableByteArray# s -> Int# -> FloatX8# -> State# s -> State# s-writeFloatArrayAsFloatX8# = let x = x in x---- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. --writeDoubleArrayAsDoubleX4# :: MutableByteArray# s -> Int# -> DoubleX4# -> State# s -> State# s-writeDoubleArrayAsDoubleX4# = let x = x in x---- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. --writeFloatArrayAsFloatX16# :: MutableByteArray# s -> Int# -> FloatX16# -> State# s -> State# s-writeFloatArrayAsFloatX16# = let x = x in x---- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. --writeDoubleArrayAsDoubleX8# :: MutableByteArray# s -> Int# -> DoubleX8# -> State# s -> State# s-writeDoubleArrayAsDoubleX8# = let x = x in x---- | Reads vector; offset in scalar elements. --indexInt8OffAddrAsInt8X16# :: Addr# -> Int# -> Int8X16#-indexInt8OffAddrAsInt8X16# = let x = x in x---- | Reads vector; offset in scalar elements. --indexInt16OffAddrAsInt16X8# :: Addr# -> Int# -> Int16X8#-indexInt16OffAddrAsInt16X8# = let x = x in x---- | Reads vector; offset in scalar elements. --indexInt32OffAddrAsInt32X4# :: Addr# -> Int# -> Int32X4#-indexInt32OffAddrAsInt32X4# = let x = x in x---- | Reads vector; offset in scalar elements. --indexInt64OffAddrAsInt64X2# :: Addr# -> Int# -> Int64X2#-indexInt64OffAddrAsInt64X2# = let x = x in x---- | Reads vector; offset in scalar elements. --indexInt8OffAddrAsInt8X32# :: Addr# -> Int# -> Int8X32#-indexInt8OffAddrAsInt8X32# = let x = x in x---- | Reads vector; offset in scalar elements. --indexInt16OffAddrAsInt16X16# :: Addr# -> Int# -> Int16X16#-indexInt16OffAddrAsInt16X16# = let x = x in x---- | Reads vector; offset in scalar elements. --indexInt32OffAddrAsInt32X8# :: Addr# -> Int# -> Int32X8#-indexInt32OffAddrAsInt32X8# = let x = x in x---- | Reads vector; offset in scalar elements. --indexInt64OffAddrAsInt64X4# :: Addr# -> Int# -> Int64X4#-indexInt64OffAddrAsInt64X4# = let x = x in x---- | Reads vector; offset in scalar elements. --indexInt8OffAddrAsInt8X64# :: Addr# -> Int# -> Int8X64#-indexInt8OffAddrAsInt8X64# = let x = x in x---- | Reads vector; offset in scalar elements. --indexInt16OffAddrAsInt16X32# :: Addr# -> Int# -> Int16X32#-indexInt16OffAddrAsInt16X32# = let x = x in x---- | Reads vector; offset in scalar elements. --indexInt32OffAddrAsInt32X16# :: Addr# -> Int# -> Int32X16#-indexInt32OffAddrAsInt32X16# = let x = x in x---- | Reads vector; offset in scalar elements. --indexInt64OffAddrAsInt64X8# :: Addr# -> Int# -> Int64X8#-indexInt64OffAddrAsInt64X8# = let x = x in x---- | Reads vector; offset in scalar elements. --indexWord8OffAddrAsWord8X16# :: Addr# -> Int# -> Word8X16#-indexWord8OffAddrAsWord8X16# = let x = x in x---- | Reads vector; offset in scalar elements. --indexWord16OffAddrAsWord16X8# :: Addr# -> Int# -> Word16X8#-indexWord16OffAddrAsWord16X8# = let x = x in x---- | Reads vector; offset in scalar elements. --indexWord32OffAddrAsWord32X4# :: Addr# -> Int# -> Word32X4#-indexWord32OffAddrAsWord32X4# = let x = x in x---- | Reads vector; offset in scalar elements. --indexWord64OffAddrAsWord64X2# :: Addr# -> Int# -> Word64X2#-indexWord64OffAddrAsWord64X2# = let x = x in x---- | Reads vector; offset in scalar elements. --indexWord8OffAddrAsWord8X32# :: Addr# -> Int# -> Word8X32#-indexWord8OffAddrAsWord8X32# = let x = x in x---- | Reads vector; offset in scalar elements. --indexWord16OffAddrAsWord16X16# :: Addr# -> Int# -> Word16X16#-indexWord16OffAddrAsWord16X16# = let x = x in x---- | Reads vector; offset in scalar elements. --indexWord32OffAddrAsWord32X8# :: Addr# -> Int# -> Word32X8#-indexWord32OffAddrAsWord32X8# = let x = x in x---- | Reads vector; offset in scalar elements. --indexWord64OffAddrAsWord64X4# :: Addr# -> Int# -> Word64X4#-indexWord64OffAddrAsWord64X4# = let x = x in x---- | Reads vector; offset in scalar elements. --indexWord8OffAddrAsWord8X64# :: Addr# -> Int# -> Word8X64#-indexWord8OffAddrAsWord8X64# = let x = x in x---- | Reads vector; offset in scalar elements. --indexWord16OffAddrAsWord16X32# :: Addr# -> Int# -> Word16X32#-indexWord16OffAddrAsWord16X32# = let x = x in x---- | Reads vector; offset in scalar elements. --indexWord32OffAddrAsWord32X16# :: Addr# -> Int# -> Word32X16#-indexWord32OffAddrAsWord32X16# = let x = x in x---- | Reads vector; offset in scalar elements. --indexWord64OffAddrAsWord64X8# :: Addr# -> Int# -> Word64X8#-indexWord64OffAddrAsWord64X8# = let x = x in x---- | Reads vector; offset in scalar elements. --indexFloatOffAddrAsFloatX4# :: Addr# -> Int# -> FloatX4#-indexFloatOffAddrAsFloatX4# = let x = x in x---- | Reads vector; offset in scalar elements. --indexDoubleOffAddrAsDoubleX2# :: Addr# -> Int# -> DoubleX2#-indexDoubleOffAddrAsDoubleX2# = let x = x in x---- | Reads vector; offset in scalar elements. --indexFloatOffAddrAsFloatX8# :: Addr# -> Int# -> FloatX8#-indexFloatOffAddrAsFloatX8# = let x = x in x---- | Reads vector; offset in scalar elements. --indexDoubleOffAddrAsDoubleX4# :: Addr# -> Int# -> DoubleX4#-indexDoubleOffAddrAsDoubleX4# = let x = x in x---- | Reads vector; offset in scalar elements. --indexFloatOffAddrAsFloatX16# :: Addr# -> Int# -> FloatX16#-indexFloatOffAddrAsFloatX16# = let x = x in x---- | Reads vector; offset in scalar elements. --indexDoubleOffAddrAsDoubleX8# :: Addr# -> Int# -> DoubleX8#-indexDoubleOffAddrAsDoubleX8# = let x = x in x---- | Reads vector; offset in scalar elements. --readInt8OffAddrAsInt8X16# :: Addr# -> Int# -> State# s -> (# State# s,Int8X16# #)-readInt8OffAddrAsInt8X16# = let x = x in x---- | Reads vector; offset in scalar elements. --readInt16OffAddrAsInt16X8# :: Addr# -> Int# -> State# s -> (# State# s,Int16X8# #)-readInt16OffAddrAsInt16X8# = let x = x in x---- | Reads vector; offset in scalar elements. --readInt32OffAddrAsInt32X4# :: Addr# -> Int# -> State# s -> (# State# s,Int32X4# #)-readInt32OffAddrAsInt32X4# = let x = x in x---- | Reads vector; offset in scalar elements. --readInt64OffAddrAsInt64X2# :: Addr# -> Int# -> State# s -> (# State# s,Int64X2# #)-readInt64OffAddrAsInt64X2# = let x = x in x---- | Reads vector; offset in scalar elements. --readInt8OffAddrAsInt8X32# :: Addr# -> Int# -> State# s -> (# State# s,Int8X32# #)-readInt8OffAddrAsInt8X32# = let x = x in x---- | Reads vector; offset in scalar elements. --readInt16OffAddrAsInt16X16# :: Addr# -> Int# -> State# s -> (# State# s,Int16X16# #)-readInt16OffAddrAsInt16X16# = let x = x in x---- | Reads vector; offset in scalar elements. --readInt32OffAddrAsInt32X8# :: Addr# -> Int# -> State# s -> (# State# s,Int32X8# #)-readInt32OffAddrAsInt32X8# = let x = x in x---- | Reads vector; offset in scalar elements. --readInt64OffAddrAsInt64X4# :: Addr# -> Int# -> State# s -> (# State# s,Int64X4# #)-readInt64OffAddrAsInt64X4# = let x = x in x---- | Reads vector; offset in scalar elements. --readInt8OffAddrAsInt8X64# :: Addr# -> Int# -> State# s -> (# State# s,Int8X64# #)-readInt8OffAddrAsInt8X64# = let x = x in x---- | Reads vector; offset in scalar elements. --readInt16OffAddrAsInt16X32# :: Addr# -> Int# -> State# s -> (# State# s,Int16X32# #)-readInt16OffAddrAsInt16X32# = let x = x in x---- | Reads vector; offset in scalar elements. --readInt32OffAddrAsInt32X16# :: Addr# -> Int# -> State# s -> (# State# s,Int32X16# #)-readInt32OffAddrAsInt32X16# = let x = x in x---- | Reads vector; offset in scalar elements. --readInt64OffAddrAsInt64X8# :: Addr# -> Int# -> State# s -> (# State# s,Int64X8# #)-readInt64OffAddrAsInt64X8# = let x = x in x---- | Reads vector; offset in scalar elements. --readWord8OffAddrAsWord8X16# :: Addr# -> Int# -> State# s -> (# State# s,Word8X16# #)-readWord8OffAddrAsWord8X16# = let x = x in x---- | Reads vector; offset in scalar elements. --readWord16OffAddrAsWord16X8# :: Addr# -> Int# -> State# s -> (# State# s,Word16X8# #)-readWord16OffAddrAsWord16X8# = let x = x in x---- | Reads vector; offset in scalar elements. --readWord32OffAddrAsWord32X4# :: Addr# -> Int# -> State# s -> (# State# s,Word32X4# #)-readWord32OffAddrAsWord32X4# = let x = x in x---- | Reads vector; offset in scalar elements. --readWord64OffAddrAsWord64X2# :: Addr# -> Int# -> State# s -> (# State# s,Word64X2# #)-readWord64OffAddrAsWord64X2# = let x = x in x---- | Reads vector; offset in scalar elements. --readWord8OffAddrAsWord8X32# :: Addr# -> Int# -> State# s -> (# State# s,Word8X32# #)-readWord8OffAddrAsWord8X32# = let x = x in x---- | Reads vector; offset in scalar elements. --readWord16OffAddrAsWord16X16# :: Addr# -> Int# -> State# s -> (# State# s,Word16X16# #)-readWord16OffAddrAsWord16X16# = let x = x in x---- | Reads vector; offset in scalar elements. --readWord32OffAddrAsWord32X8# :: Addr# -> Int# -> State# s -> (# State# s,Word32X8# #)-readWord32OffAddrAsWord32X8# = let x = x in x---- | Reads vector; offset in scalar elements. --readWord64OffAddrAsWord64X4# :: Addr# -> Int# -> State# s -> (# State# s,Word64X4# #)-readWord64OffAddrAsWord64X4# = let x = x in x---- | Reads vector; offset in scalar elements. --readWord8OffAddrAsWord8X64# :: Addr# -> Int# -> State# s -> (# State# s,Word8X64# #)-readWord8OffAddrAsWord8X64# = let x = x in x---- | Reads vector; offset in scalar elements. --readWord16OffAddrAsWord16X32# :: Addr# -> Int# -> State# s -> (# State# s,Word16X32# #)-readWord16OffAddrAsWord16X32# = let x = x in x---- | Reads vector; offset in scalar elements. --readWord32OffAddrAsWord32X16# :: Addr# -> Int# -> State# s -> (# State# s,Word32X16# #)-readWord32OffAddrAsWord32X16# = let x = x in x---- | Reads vector; offset in scalar elements. --readWord64OffAddrAsWord64X8# :: Addr# -> Int# -> State# s -> (# State# s,Word64X8# #)-readWord64OffAddrAsWord64X8# = let x = x in x---- | Reads vector; offset in scalar elements. --readFloatOffAddrAsFloatX4# :: Addr# -> Int# -> State# s -> (# State# s,FloatX4# #)-readFloatOffAddrAsFloatX4# = let x = x in x---- | Reads vector; offset in scalar elements. --readDoubleOffAddrAsDoubleX2# :: Addr# -> Int# -> State# s -> (# State# s,DoubleX2# #)-readDoubleOffAddrAsDoubleX2# = let x = x in x---- | Reads vector; offset in scalar elements. --readFloatOffAddrAsFloatX8# :: Addr# -> Int# -> State# s -> (# State# s,FloatX8# #)-readFloatOffAddrAsFloatX8# = let x = x in x---- | Reads vector; offset in scalar elements. --readDoubleOffAddrAsDoubleX4# :: Addr# -> Int# -> State# s -> (# State# s,DoubleX4# #)-readDoubleOffAddrAsDoubleX4# = let x = x in x---- | Reads vector; offset in scalar elements. --readFloatOffAddrAsFloatX16# :: Addr# -> Int# -> State# s -> (# State# s,FloatX16# #)-readFloatOffAddrAsFloatX16# = let x = x in x---- | Reads vector; offset in scalar elements. --readDoubleOffAddrAsDoubleX8# :: Addr# -> Int# -> State# s -> (# State# s,DoubleX8# #)-readDoubleOffAddrAsDoubleX8# = let x = x in x---- | Write vector; offset in scalar elements. --writeInt8OffAddrAsInt8X16# :: Addr# -> Int# -> Int8X16# -> State# s -> State# s-writeInt8OffAddrAsInt8X16# = let x = x in x---- | Write vector; offset in scalar elements. --writeInt16OffAddrAsInt16X8# :: Addr# -> Int# -> Int16X8# -> State# s -> State# s-writeInt16OffAddrAsInt16X8# = let x = x in x---- | Write vector; offset in scalar elements. --writeInt32OffAddrAsInt32X4# :: Addr# -> Int# -> Int32X4# -> State# s -> State# s-writeInt32OffAddrAsInt32X4# = let x = x in x---- | Write vector; offset in scalar elements. --writeInt64OffAddrAsInt64X2# :: Addr# -> Int# -> Int64X2# -> State# s -> State# s-writeInt64OffAddrAsInt64X2# = let x = x in x---- | Write vector; offset in scalar elements. --writeInt8OffAddrAsInt8X32# :: Addr# -> Int# -> Int8X32# -> State# s -> State# s-writeInt8OffAddrAsInt8X32# = let x = x in x---- | Write vector; offset in scalar elements. --writeInt16OffAddrAsInt16X16# :: Addr# -> Int# -> Int16X16# -> State# s -> State# s-writeInt16OffAddrAsInt16X16# = let x = x in x---- | Write vector; offset in scalar elements. --writeInt32OffAddrAsInt32X8# :: Addr# -> Int# -> Int32X8# -> State# s -> State# s-writeInt32OffAddrAsInt32X8# = let x = x in x---- | Write vector; offset in scalar elements. --writeInt64OffAddrAsInt64X4# :: Addr# -> Int# -> Int64X4# -> State# s -> State# s-writeInt64OffAddrAsInt64X4# = let x = x in x---- | Write vector; offset in scalar elements. --writeInt8OffAddrAsInt8X64# :: Addr# -> Int# -> Int8X64# -> State# s -> State# s-writeInt8OffAddrAsInt8X64# = let x = x in x---- | Write vector; offset in scalar elements. --writeInt16OffAddrAsInt16X32# :: Addr# -> Int# -> Int16X32# -> State# s -> State# s-writeInt16OffAddrAsInt16X32# = let x = x in x---- | Write vector; offset in scalar elements. --writeInt32OffAddrAsInt32X16# :: Addr# -> Int# -> Int32X16# -> State# s -> State# s-writeInt32OffAddrAsInt32X16# = let x = x in x---- | Write vector; offset in scalar elements. --writeInt64OffAddrAsInt64X8# :: Addr# -> Int# -> Int64X8# -> State# s -> State# s-writeInt64OffAddrAsInt64X8# = let x = x in x---- | Write vector; offset in scalar elements. --writeWord8OffAddrAsWord8X16# :: Addr# -> Int# -> Word8X16# -> State# s -> State# s-writeWord8OffAddrAsWord8X16# = let x = x in x---- | Write vector; offset in scalar elements. --writeWord16OffAddrAsWord16X8# :: Addr# -> Int# -> Word16X8# -> State# s -> State# s-writeWord16OffAddrAsWord16X8# = let x = x in x---- | Write vector; offset in scalar elements. --writeWord32OffAddrAsWord32X4# :: Addr# -> Int# -> Word32X4# -> State# s -> State# s-writeWord32OffAddrAsWord32X4# = let x = x in x---- | Write vector; offset in scalar elements. --writeWord64OffAddrAsWord64X2# :: Addr# -> Int# -> Word64X2# -> State# s -> State# s-writeWord64OffAddrAsWord64X2# = let x = x in x---- | Write vector; offset in scalar elements. --writeWord8OffAddrAsWord8X32# :: Addr# -> Int# -> Word8X32# -> State# s -> State# s-writeWord8OffAddrAsWord8X32# = let x = x in x---- | Write vector; offset in scalar elements. --writeWord16OffAddrAsWord16X16# :: Addr# -> Int# -> Word16X16# -> State# s -> State# s-writeWord16OffAddrAsWord16X16# = let x = x in x---- | Write vector; offset in scalar elements. --writeWord32OffAddrAsWord32X8# :: Addr# -> Int# -> Word32X8# -> State# s -> State# s-writeWord32OffAddrAsWord32X8# = let x = x in x---- | Write vector; offset in scalar elements. --writeWord64OffAddrAsWord64X4# :: Addr# -> Int# -> Word64X4# -> State# s -> State# s-writeWord64OffAddrAsWord64X4# = let x = x in x---- | Write vector; offset in scalar elements. --writeWord8OffAddrAsWord8X64# :: Addr# -> Int# -> Word8X64# -> State# s -> State# s-writeWord8OffAddrAsWord8X64# = let x = x in x---- | Write vector; offset in scalar elements. --writeWord16OffAddrAsWord16X32# :: Addr# -> Int# -> Word16X32# -> State# s -> State# s-writeWord16OffAddrAsWord16X32# = let x = x in x---- | Write vector; offset in scalar elements. --writeWord32OffAddrAsWord32X16# :: Addr# -> Int# -> Word32X16# -> State# s -> State# s-writeWord32OffAddrAsWord32X16# = let x = x in x---- | Write vector; offset in scalar elements. --writeWord64OffAddrAsWord64X8# :: Addr# -> Int# -> Word64X8# -> State# s -> State# s-writeWord64OffAddrAsWord64X8# = let x = x in x---- | Write vector; offset in scalar elements. --writeFloatOffAddrAsFloatX4# :: Addr# -> Int# -> FloatX4# -> State# s -> State# s-writeFloatOffAddrAsFloatX4# = let x = x in x---- | Write vector; offset in scalar elements. --writeDoubleOffAddrAsDoubleX2# :: Addr# -> Int# -> DoubleX2# -> State# s -> State# s-writeDoubleOffAddrAsDoubleX2# = let x = x in x---- | Write vector; offset in scalar elements. --writeFloatOffAddrAsFloatX8# :: Addr# -> Int# -> FloatX8# -> State# s -> State# s-writeFloatOffAddrAsFloatX8# = let x = x in x---- | Write vector; offset in scalar elements. --writeDoubleOffAddrAsDoubleX4# :: Addr# -> Int# -> DoubleX4# -> State# s -> State# s-writeDoubleOffAddrAsDoubleX4# = let x = x in x---- | Write vector; offset in scalar elements. --writeFloatOffAddrAsFloatX16# :: Addr# -> Int# -> FloatX16# -> State# s -> State# s-writeFloatOffAddrAsFloatX16# = let x = x in x---- | Write vector; offset in scalar elements. --writeDoubleOffAddrAsDoubleX8# :: Addr# -> Int# -> DoubleX8# -> State# s -> State# s-writeDoubleOffAddrAsDoubleX8# = let x = x in x--prefetchByteArray3# :: ByteArray# -> Int# -> ByteArray#-prefetchByteArray3# = let x = x in x--prefetchMutableByteArray3# :: MutableByteArray# s -> Int# -> State# s -> State# s-prefetchMutableByteArray3# = let x = x in x--prefetchAddr3# :: Addr# -> Int# -> Addr#-prefetchAddr3# = let x = x in x--prefetchByteArray2# :: ByteArray# -> Int# -> ByteArray#-prefetchByteArray2# = let x = x in x--prefetchMutableByteArray2# :: MutableByteArray# s -> Int# -> State# s -> State# s-prefetchMutableByteArray2# = let x = x in x--prefetchAddr2# :: Addr# -> Int# -> Addr#-prefetchAddr2# = let x = x in x--prefetchByteArray1# :: ByteArray# -> Int# -> ByteArray#-prefetchByteArray1# = let x = x in x--prefetchMutableByteArray1# :: MutableByteArray# s -> Int# -> State# s -> State# s-prefetchMutableByteArray1# = let x = x in x--prefetchAddr1# :: Addr# -> Int# -> Addr#-prefetchAddr1# = let x = x in x--prefetchByteArray0# :: ByteArray# -> Int# -> ByteArray#-prefetchByteArray0# = let x = x in x--prefetchMutableByteArray0# :: MutableByteArray# s -> Int# -> State# s -> State# s-prefetchMutableByteArray0# = let x = x in x--prefetchAddr0# :: Addr# -> Int# -> Addr#-prefetchAddr0# = let x = x in x+{-# LANGUAGE Unsafe #-}+{-# LANGUAGE MagicHash #-}+{-# LANGUAGE MultiParamTypeClasses #-}+{-# LANGUAGE NoImplicitPrelude #-}+{-# LANGUAGE UnboxedTuples #-}+module GHC.Prim (+ +-- * The word size story.+-- |Haskell98 specifies that signed integers (type @Int@)+-- must contain at least 30 bits. GHC always implements @Int@ using the primitive type @Int\#@, whose size equals+-- the @MachDeps.h@ constant @WORD\_SIZE\_IN\_BITS@.+-- This is normally set based on the @config.h@ parameter+-- @SIZEOF\_HSWORD@, i.e., 32 bits on 32-bit machines, 64+-- bits on 64-bit machines. However, it can also be explicitly+-- set to a smaller number, e.g., 31 bits, to allow the+-- possibility of using tag bits. Currently GHC itself has only+-- 32-bit and 64-bit variants, but 30 or 31-bit code can be+-- exported as an external core file for use in other back ends.+-- +-- GHC also implements a primitive unsigned integer type @Word\#@ which always has the same number of bits as @Int\#@.+-- +-- In addition, GHC supports families of explicit-sized integers+-- and words at 8, 16, 32, and 64 bits, with the usual+-- arithmetic operations, comparisons, and a range of+-- conversions. The 8-bit and 16-bit sizes are always+-- represented as @Int\#@ and @Word\#@, and the+-- operations implemented in terms of the the primops on these+-- types, with suitable range restrictions on the results (using+-- the @narrow$n$Int\#@ and @narrow$n$Word\#@ families+-- of primops. The 32-bit sizes are represented using @Int\#@ and @Word\#@ when @WORD\_SIZE\_IN\_BITS@+-- $\geq$ 32; otherwise, these are represented using distinct+-- primitive types @Int32\#@ and @Word32\#@. These (when+-- needed) have a complete set of corresponding operations;+-- however, nearly all of these are implemented as external C+-- functions rather than as primops. Exactly the same story+-- applies to the 64-bit sizes. All of these details are hidden+-- under the @PrelInt@ and @PrelWord@ modules, which use+-- @\#if@-defs to invoke the appropriate types and+-- operators.+-- +-- Word size also matters for the families of primops for+-- indexing\/reading\/writing fixed-size quantities at offsets+-- from an array base, address, or foreign pointer. Here, a+-- slightly different approach is taken. The names of these+-- primops are fixed, but their /types/ vary according to+-- the value of @WORD\_SIZE\_IN\_BITS@. For example, if word+-- size is at least 32 bits then an operator like+-- @indexInt32Array\#@ has type @ByteArray\# -> Int\# -> Int\#@; otherwise it has type @ByteArray\# -> Int\# -> Int32\#@. This approach confines the necessary @\#if@-defs to this file; no conditional compilation is needed+-- in the files that expose these primops.+-- +-- Finally, there are strongly deprecated primops for coercing+-- between @Addr\#@, the primitive type of machine+-- addresses, and @Int\#@. These are pretty bogus anyway,+-- but will work on existing 32-bit and 64-bit GHC targets; they+-- are completely bogus when tag bits are used in @Int\#@,+-- so are not available in this case. +++ +-- * Char#+-- |Operations on 31-bit characters.+++ Char#,+ gtChar#,+ geChar#,+ eqChar#,+ neChar#,+ ltChar#,+ leChar#,+ ord#,+ +-- * Int#+-- |Operations on native-size integers (30+ bits).+++ Int#,+ (+#),+ (-#),+ (*#),+ mulIntMayOflo#,+ quotInt#,+ remInt#,+ quotRemInt#,+ andI#,+ orI#,+ xorI#,+ notI#,+ negateInt#,+ addIntC#,+ subIntC#,+ (>#),+ (>=#),+ (==#),+ (/=#),+ (<#),+ (<=#),+ chr#,+ int2Word#,+ int2Float#,+ int2Double#,+ word2Float#,+ word2Double#,+ uncheckedIShiftL#,+ uncheckedIShiftRA#,+ uncheckedIShiftRL#,+ +-- * Word#+-- |Operations on native-sized unsigned words (30+ bits).+++ Word#,+ plusWord#,+ plusWord2#,+ minusWord#,+ timesWord#,+ timesWord2#,+ quotWord#,+ remWord#,+ quotRemWord#,+ quotRemWord2#,+ and#,+ or#,+ xor#,+ not#,+ uncheckedShiftL#,+ uncheckedShiftRL#,+ word2Int#,+ gtWord#,+ geWord#,+ eqWord#,+ neWord#,+ ltWord#,+ leWord#,+ popCnt8#,+ popCnt16#,+ popCnt32#,+ popCnt64#,+ popCnt#,+ clz8#,+ clz16#,+ clz32#,+ clz64#,+ clz#,+ ctz8#,+ ctz16#,+ ctz32#,+ ctz64#,+ ctz#,+ byteSwap16#,+ byteSwap32#,+ byteSwap64#,+ byteSwap#,+ +-- * Narrowings+-- |Explicit narrowing of native-sized ints or words.+++ narrow8Int#,+ narrow16Int#,+ narrow32Int#,+ narrow8Word#,+ narrow16Word#,+ narrow32Word#,+ +-- * Double#+-- |Operations on double-precision (64 bit) floating-point numbers.+++ Double#,+ (>##),+ (>=##),+ (==##),+ (/=##),+ (<##),+ (<=##),+ (+##),+ (-##),+ (*##),+ (/##),+ negateDouble#,+ double2Int#,+ double2Float#,+ expDouble#,+ logDouble#,+ sqrtDouble#,+ sinDouble#,+ cosDouble#,+ tanDouble#,+ asinDouble#,+ acosDouble#,+ atanDouble#,+ sinhDouble#,+ coshDouble#,+ tanhDouble#,+ (**##),+ decodeDouble_2Int#,+ decodeDouble_Int64#,+ +-- * Float#+-- |Operations on single-precision (32-bit) floating-point numbers.+++ Float#,+ gtFloat#,+ geFloat#,+ eqFloat#,+ neFloat#,+ ltFloat#,+ leFloat#,+ plusFloat#,+ minusFloat#,+ timesFloat#,+ divideFloat#,+ negateFloat#,+ float2Int#,+ expFloat#,+ logFloat#,+ sqrtFloat#,+ sinFloat#,+ cosFloat#,+ tanFloat#,+ asinFloat#,+ acosFloat#,+ atanFloat#,+ sinhFloat#,+ coshFloat#,+ tanhFloat#,+ powerFloat#,+ float2Double#,+ decodeFloat_Int#,+ +-- * Arrays+-- |Operations on @Array\#@.+++ Array#,+ MutableArray#,+ newArray#,+ sameMutableArray#,+ readArray#,+ writeArray#,+ sizeofArray#,+ sizeofMutableArray#,+ indexArray#,+ unsafeFreezeArray#,+ unsafeThawArray#,+ copyArray#,+ copyMutableArray#,+ cloneArray#,+ cloneMutableArray#,+ freezeArray#,+ thawArray#,+ casArray#,+ +-- * Small Arrays+-- |Operations on @SmallArray\#@. A @SmallArray\#@ works+-- just like an @Array\#@, but with different space use and+-- performance characteristics (that are often useful with small+-- arrays). The @SmallArray\#@ and @SmallMutableArray#@+-- lack a \`card table\'. The purpose of a card table is to avoid+-- having to scan every element of the array on each GC by+-- keeping track of which elements have changed since the last GC+-- and only scanning those that have changed. So the consequence+-- of there being no card table is that the representation is+-- somewhat smaller and the writes are somewhat faster (because+-- the card table does not need to be updated). The disadvantage+-- of course is that for a @SmallMutableArray#@ the whole+-- array has to be scanned on each GC. Thus it is best suited for+-- use cases where the mutable array is not long lived, e.g.+-- where a mutable array is initialised quickly and then frozen+-- to become an immutable @SmallArray\#@.+-- +++ SmallArray#,+ SmallMutableArray#,+ newSmallArray#,+ sameSmallMutableArray#,+ readSmallArray#,+ writeSmallArray#,+ sizeofSmallArray#,+ sizeofSmallMutableArray#,+ indexSmallArray#,+ unsafeFreezeSmallArray#,+ unsafeThawSmallArray#,+ copySmallArray#,+ copySmallMutableArray#,+ cloneSmallArray#,+ cloneSmallMutableArray#,+ freezeSmallArray#,+ thawSmallArray#,+ casSmallArray#,+ +-- * Byte Arrays+-- |Operations on @ByteArray\#@. A @ByteArray\#@ is a just a region of+-- raw memory in the garbage-collected heap, which is not+-- scanned for pointers. It carries its own size (in bytes).+-- There are+-- three sets of operations for accessing byte array contents:+-- index for reading from immutable byte arrays, and read\/write+-- for mutable byte arrays. Each set contains operations for a+-- range of useful primitive data types. Each operation takes+-- an offset measured in terms of the size of the primitive type+-- being read or written.+++ ByteArray#,+ MutableByteArray#,+ newByteArray#,+ newPinnedByteArray#,+ newAlignedPinnedByteArray#,+ byteArrayContents#,+ sameMutableByteArray#,+ shrinkMutableByteArray#,+ resizeMutableByteArray#,+ unsafeFreezeByteArray#,+ sizeofByteArray#,+ sizeofMutableByteArray#,+ indexCharArray#,+ indexWideCharArray#,+ indexIntArray#,+ indexWordArray#,+ indexAddrArray#,+ indexFloatArray#,+ indexDoubleArray#,+ indexStablePtrArray#,+ indexInt8Array#,+ indexInt16Array#,+ indexInt32Array#,+ indexInt64Array#,+ indexWord8Array#,+ indexWord16Array#,+ indexWord32Array#,+ indexWord64Array#,+ readCharArray#,+ readWideCharArray#,+ readIntArray#,+ readWordArray#,+ readAddrArray#,+ readFloatArray#,+ readDoubleArray#,+ readStablePtrArray#,+ readInt8Array#,+ readInt16Array#,+ readInt32Array#,+ readInt64Array#,+ readWord8Array#,+ readWord16Array#,+ readWord32Array#,+ readWord64Array#,+ writeCharArray#,+ writeWideCharArray#,+ writeIntArray#,+ writeWordArray#,+ writeAddrArray#,+ writeFloatArray#,+ writeDoubleArray#,+ writeStablePtrArray#,+ writeInt8Array#,+ writeInt16Array#,+ writeInt32Array#,+ writeInt64Array#,+ writeWord8Array#,+ writeWord16Array#,+ writeWord32Array#,+ writeWord64Array#,+ copyByteArray#,+ copyMutableByteArray#,+ copyByteArrayToAddr#,+ copyMutableByteArrayToAddr#,+ copyAddrToByteArray#,+ setByteArray#,+ atomicReadIntArray#,+ atomicWriteIntArray#,+ casIntArray#,+ fetchAddIntArray#,+ fetchSubIntArray#,+ fetchAndIntArray#,+ fetchNandIntArray#,+ fetchOrIntArray#,+ fetchXorIntArray#,+ +-- * Arrays of arrays+-- |Operations on @ArrayArray\#@. An @ArrayArray\#@ contains references to {\em unpointed}+-- arrays, such as @ByteArray\#s@. Hence, it is not parameterised by the element types,+-- just like a @ByteArray\#@, but it needs to be scanned during GC, just like an @Array#@.+-- We represent an @ArrayArray\#@ exactly as a @Array\#@, but provide element-type-specific+-- indexing, reading, and writing.+++ ArrayArray#,+ MutableArrayArray#,+ newArrayArray#,+ sameMutableArrayArray#,+ unsafeFreezeArrayArray#,+ sizeofArrayArray#,+ sizeofMutableArrayArray#,+ indexByteArrayArray#,+ indexArrayArrayArray#,+ readByteArrayArray#,+ readMutableByteArrayArray#,+ readArrayArrayArray#,+ readMutableArrayArrayArray#,+ writeByteArrayArray#,+ writeMutableByteArrayArray#,+ writeArrayArrayArray#,+ writeMutableArrayArrayArray#,+ copyArrayArray#,+ copyMutableArrayArray#,+ +-- * Addr#+-- |+++ Addr#,+ nullAddr#,+ plusAddr#,+ minusAddr#,+ remAddr#,+ addr2Int#,+ int2Addr#,+ gtAddr#,+ geAddr#,+ eqAddr#,+ neAddr#,+ ltAddr#,+ leAddr#,+ indexCharOffAddr#,+ indexWideCharOffAddr#,+ indexIntOffAddr#,+ indexWordOffAddr#,+ indexAddrOffAddr#,+ indexFloatOffAddr#,+ indexDoubleOffAddr#,+ indexStablePtrOffAddr#,+ indexInt8OffAddr#,+ indexInt16OffAddr#,+ indexInt32OffAddr#,+ indexInt64OffAddr#,+ indexWord8OffAddr#,+ indexWord16OffAddr#,+ indexWord32OffAddr#,+ indexWord64OffAddr#,+ readCharOffAddr#,+ readWideCharOffAddr#,+ readIntOffAddr#,+ readWordOffAddr#,+ readAddrOffAddr#,+ readFloatOffAddr#,+ readDoubleOffAddr#,+ readStablePtrOffAddr#,+ readInt8OffAddr#,+ readInt16OffAddr#,+ readInt32OffAddr#,+ readInt64OffAddr#,+ readWord8OffAddr#,+ readWord16OffAddr#,+ readWord32OffAddr#,+ readWord64OffAddr#,+ writeCharOffAddr#,+ writeWideCharOffAddr#,+ writeIntOffAddr#,+ writeWordOffAddr#,+ writeAddrOffAddr#,+ writeFloatOffAddr#,+ writeDoubleOffAddr#,+ writeStablePtrOffAddr#,+ writeInt8OffAddr#,+ writeInt16OffAddr#,+ writeInt32OffAddr#,+ writeInt64OffAddr#,+ writeWord8OffAddr#,+ writeWord16OffAddr#,+ writeWord32OffAddr#,+ writeWord64OffAddr#,+ +-- * Mutable variables+-- |Operations on MutVar\#s.+++ MutVar#,+ newMutVar#,+ readMutVar#,+ writeMutVar#,+ sameMutVar#,+ atomicModifyMutVar#,+ casMutVar#,+ +-- * Exceptions+-- |+++ catch#,+ raise#,+ raiseIO#,+ maskAsyncExceptions#,+ maskUninterruptible#,+ unmaskAsyncExceptions#,+ getMaskingState#,+ +-- * STM-accessible Mutable Variables+-- |+++ TVar#,+ atomically#,+ retry#,+ catchRetry#,+ catchSTM#,+ check#,+ newTVar#,+ readTVar#,+ readTVarIO#,+ writeTVar#,+ sameTVar#,+ +-- * Synchronized Mutable Variables+-- |Operations on @MVar\#@s. +++ MVar#,+ newMVar#,+ takeMVar#,+ tryTakeMVar#,+ putMVar#,+ tryPutMVar#,+ readMVar#,+ tryReadMVar#,+ sameMVar#,+ isEmptyMVar#,+ +-- * Delay\/wait operations+-- |+++ delay#,+ waitRead#,+ waitWrite#,+ +-- * Concurrency primitives+-- |+++ State#,+ RealWorld,+ ThreadId#,+ fork#,+ forkOn#,+ killThread#,+ yield#,+ myThreadId#,+ labelThread#,+ isCurrentThreadBound#,+ noDuplicate#,+ threadStatus#,+ +-- * Weak pointers+-- |+++ Weak#,+ mkWeak#,+ mkWeakNoFinalizer#,+ addCFinalizerToWeak#,+ deRefWeak#,+ finalizeWeak#,+ touch#,+ +-- * Stable pointers and names+-- |+++ StablePtr#,+ StableName#,+ makeStablePtr#,+ deRefStablePtr#,+ eqStablePtr#,+ makeStableName#,+ eqStableName#,+ stableNameToInt#,+ +-- * Unsafe pointer equality+-- |+++ reallyUnsafePtrEquality#,+ +-- * Parallelism+-- |+++ par#,+ spark#,+ seq#,+ getSpark#,+ numSparks#,+ parGlobal#,+ parLocal#,+ parAt#,+ parAtAbs#,+ parAtRel#,+ parAtForNow#,+ +-- * Tag to enum stuff+-- |Convert back and forth between values of enumerated types+-- and small integers.+++ dataToTag#,+ tagToEnum#,+ +-- * Bytecode operations+-- |Support for the bytecode interpreter and linker.+++ BCO#,+ addrToAny#,+ mkApUpd0#,+ newBCO#,+ unpackClosure#,+ getApStackVal#,+ +-- * Misc+-- |These aren\'t nearly as wired in as Etc...+++ getCCSOf#,+ getCurrentCCS#,+ +-- * Etc+-- |Miscellaneous built-ins+++ Proxy#,+ proxy#,+ seq,+ Any,+ AnyK,+ unsafeCoerce#,+ traceEvent#,+ traceMarker#,+ +-- * Safe coercions+-- |+++ coerce,+ +-- * SIMD Vectors+-- |Operations on SIMD vectors.+++ Int8X16#,+ Int16X8#,+ Int32X4#,+ Int64X2#,+ Int8X32#,+ Int16X16#,+ Int32X8#,+ Int64X4#,+ Int8X64#,+ Int16X32#,+ Int32X16#,+ Int64X8#,+ Word8X16#,+ Word16X8#,+ Word32X4#,+ Word64X2#,+ Word8X32#,+ Word16X16#,+ Word32X8#,+ Word64X4#,+ Word8X64#,+ Word16X32#,+ Word32X16#,+ Word64X8#,+ FloatX4#,+ DoubleX2#,+ FloatX8#,+ DoubleX4#,+ FloatX16#,+ DoubleX8#,+ broadcastInt8X16#,+ broadcastInt16X8#,+ broadcastInt32X4#,+ broadcastInt64X2#,+ broadcastInt8X32#,+ broadcastInt16X16#,+ broadcastInt32X8#,+ broadcastInt64X4#,+ broadcastInt8X64#,+ broadcastInt16X32#,+ broadcastInt32X16#,+ broadcastInt64X8#,+ broadcastWord8X16#,+ broadcastWord16X8#,+ broadcastWord32X4#,+ broadcastWord64X2#,+ broadcastWord8X32#,+ broadcastWord16X16#,+ broadcastWord32X8#,+ broadcastWord64X4#,+ broadcastWord8X64#,+ broadcastWord16X32#,+ broadcastWord32X16#,+ broadcastWord64X8#,+ broadcastFloatX4#,+ broadcastDoubleX2#,+ broadcastFloatX8#,+ broadcastDoubleX4#,+ broadcastFloatX16#,+ broadcastDoubleX8#,+ packInt8X16#,+ packInt16X8#,+ packInt32X4#,+ packInt64X2#,+ packInt8X32#,+ packInt16X16#,+ packInt32X8#,+ packInt64X4#,+ packInt8X64#,+ packInt16X32#,+ packInt32X16#,+ packInt64X8#,+ packWord8X16#,+ packWord16X8#,+ packWord32X4#,+ packWord64X2#,+ packWord8X32#,+ packWord16X16#,+ packWord32X8#,+ packWord64X4#,+ packWord8X64#,+ packWord16X32#,+ packWord32X16#,+ packWord64X8#,+ packFloatX4#,+ packDoubleX2#,+ packFloatX8#,+ packDoubleX4#,+ packFloatX16#,+ packDoubleX8#,+ unpackInt8X16#,+ unpackInt16X8#,+ unpackInt32X4#,+ unpackInt64X2#,+ unpackInt8X32#,+ unpackInt16X16#,+ unpackInt32X8#,+ unpackInt64X4#,+ unpackInt8X64#,+ unpackInt16X32#,+ unpackInt32X16#,+ unpackInt64X8#,+ unpackWord8X16#,+ unpackWord16X8#,+ unpackWord32X4#,+ unpackWord64X2#,+ unpackWord8X32#,+ unpackWord16X16#,+ unpackWord32X8#,+ unpackWord64X4#,+ unpackWord8X64#,+ unpackWord16X32#,+ unpackWord32X16#,+ unpackWord64X8#,+ unpackFloatX4#,+ unpackDoubleX2#,+ unpackFloatX8#,+ unpackDoubleX4#,+ unpackFloatX16#,+ unpackDoubleX8#,+ insertInt8X16#,+ insertInt16X8#,+ insertInt32X4#,+ insertInt64X2#,+ insertInt8X32#,+ insertInt16X16#,+ insertInt32X8#,+ insertInt64X4#,+ insertInt8X64#,+ insertInt16X32#,+ insertInt32X16#,+ insertInt64X8#,+ insertWord8X16#,+ insertWord16X8#,+ insertWord32X4#,+ insertWord64X2#,+ insertWord8X32#,+ insertWord16X16#,+ insertWord32X8#,+ insertWord64X4#,+ insertWord8X64#,+ insertWord16X32#,+ insertWord32X16#,+ insertWord64X8#,+ insertFloatX4#,+ insertDoubleX2#,+ insertFloatX8#,+ insertDoubleX4#,+ insertFloatX16#,+ insertDoubleX8#,+ plusInt8X16#,+ plusInt16X8#,+ plusInt32X4#,+ plusInt64X2#,+ plusInt8X32#,+ plusInt16X16#,+ plusInt32X8#,+ plusInt64X4#,+ plusInt8X64#,+ plusInt16X32#,+ plusInt32X16#,+ plusInt64X8#,+ plusWord8X16#,+ plusWord16X8#,+ plusWord32X4#,+ plusWord64X2#,+ plusWord8X32#,+ plusWord16X16#,+ plusWord32X8#,+ plusWord64X4#,+ plusWord8X64#,+ plusWord16X32#,+ plusWord32X16#,+ plusWord64X8#,+ plusFloatX4#,+ plusDoubleX2#,+ plusFloatX8#,+ plusDoubleX4#,+ plusFloatX16#,+ plusDoubleX8#,+ minusInt8X16#,+ minusInt16X8#,+ minusInt32X4#,+ minusInt64X2#,+ minusInt8X32#,+ minusInt16X16#,+ minusInt32X8#,+ minusInt64X4#,+ minusInt8X64#,+ minusInt16X32#,+ minusInt32X16#,+ minusInt64X8#,+ minusWord8X16#,+ minusWord16X8#,+ minusWord32X4#,+ minusWord64X2#,+ minusWord8X32#,+ minusWord16X16#,+ minusWord32X8#,+ minusWord64X4#,+ minusWord8X64#,+ minusWord16X32#,+ minusWord32X16#,+ minusWord64X8#,+ minusFloatX4#,+ minusDoubleX2#,+ minusFloatX8#,+ minusDoubleX4#,+ minusFloatX16#,+ minusDoubleX8#,+ timesInt8X16#,+ timesInt16X8#,+ timesInt32X4#,+ timesInt64X2#,+ timesInt8X32#,+ timesInt16X16#,+ timesInt32X8#,+ timesInt64X4#,+ timesInt8X64#,+ timesInt16X32#,+ timesInt32X16#,+ timesInt64X8#,+ timesWord8X16#,+ timesWord16X8#,+ timesWord32X4#,+ timesWord64X2#,+ timesWord8X32#,+ timesWord16X16#,+ timesWord32X8#,+ timesWord64X4#,+ timesWord8X64#,+ timesWord16X32#,+ timesWord32X16#,+ timesWord64X8#,+ timesFloatX4#,+ timesDoubleX2#,+ timesFloatX8#,+ timesDoubleX4#,+ timesFloatX16#,+ timesDoubleX8#,+ divideFloatX4#,+ divideDoubleX2#,+ divideFloatX8#,+ divideDoubleX4#,+ divideFloatX16#,+ divideDoubleX8#,+ quotInt8X16#,+ quotInt16X8#,+ quotInt32X4#,+ quotInt64X2#,+ quotInt8X32#,+ quotInt16X16#,+ quotInt32X8#,+ quotInt64X4#,+ quotInt8X64#,+ quotInt16X32#,+ quotInt32X16#,+ quotInt64X8#,+ quotWord8X16#,+ quotWord16X8#,+ quotWord32X4#,+ quotWord64X2#,+ quotWord8X32#,+ quotWord16X16#,+ quotWord32X8#,+ quotWord64X4#,+ quotWord8X64#,+ quotWord16X32#,+ quotWord32X16#,+ quotWord64X8#,+ remInt8X16#,+ remInt16X8#,+ remInt32X4#,+ remInt64X2#,+ remInt8X32#,+ remInt16X16#,+ remInt32X8#,+ remInt64X4#,+ remInt8X64#,+ remInt16X32#,+ remInt32X16#,+ remInt64X8#,+ remWord8X16#,+ remWord16X8#,+ remWord32X4#,+ remWord64X2#,+ remWord8X32#,+ remWord16X16#,+ remWord32X8#,+ remWord64X4#,+ remWord8X64#,+ remWord16X32#,+ remWord32X16#,+ remWord64X8#,+ negateInt8X16#,+ negateInt16X8#,+ negateInt32X4#,+ negateInt64X2#,+ negateInt8X32#,+ negateInt16X16#,+ negateInt32X8#,+ negateInt64X4#,+ negateInt8X64#,+ negateInt16X32#,+ negateInt32X16#,+ negateInt64X8#,+ negateFloatX4#,+ negateDoubleX2#,+ negateFloatX8#,+ negateDoubleX4#,+ negateFloatX16#,+ negateDoubleX8#,+ indexInt8X16Array#,+ indexInt16X8Array#,+ indexInt32X4Array#,+ indexInt64X2Array#,+ indexInt8X32Array#,+ indexInt16X16Array#,+ indexInt32X8Array#,+ indexInt64X4Array#,+ indexInt8X64Array#,+ indexInt16X32Array#,+ indexInt32X16Array#,+ indexInt64X8Array#,+ indexWord8X16Array#,+ indexWord16X8Array#,+ indexWord32X4Array#,+ indexWord64X2Array#,+ indexWord8X32Array#,+ indexWord16X16Array#,+ indexWord32X8Array#,+ indexWord64X4Array#,+ indexWord8X64Array#,+ indexWord16X32Array#,+ indexWord32X16Array#,+ indexWord64X8Array#,+ indexFloatX4Array#,+ indexDoubleX2Array#,+ indexFloatX8Array#,+ indexDoubleX4Array#,+ indexFloatX16Array#,+ indexDoubleX8Array#,+ readInt8X16Array#,+ readInt16X8Array#,+ readInt32X4Array#,+ readInt64X2Array#,+ readInt8X32Array#,+ readInt16X16Array#,+ readInt32X8Array#,+ readInt64X4Array#,+ readInt8X64Array#,+ readInt16X32Array#,+ readInt32X16Array#,+ readInt64X8Array#,+ readWord8X16Array#,+ readWord16X8Array#,+ readWord32X4Array#,+ readWord64X2Array#,+ readWord8X32Array#,+ readWord16X16Array#,+ readWord32X8Array#,+ readWord64X4Array#,+ readWord8X64Array#,+ readWord16X32Array#,+ readWord32X16Array#,+ readWord64X8Array#,+ readFloatX4Array#,+ readDoubleX2Array#,+ readFloatX8Array#,+ readDoubleX4Array#,+ readFloatX16Array#,+ readDoubleX8Array#,+ writeInt8X16Array#,+ writeInt16X8Array#,+ writeInt32X4Array#,+ writeInt64X2Array#,+ writeInt8X32Array#,+ writeInt16X16Array#,+ writeInt32X8Array#,+ writeInt64X4Array#,+ writeInt8X64Array#,+ writeInt16X32Array#,+ writeInt32X16Array#,+ writeInt64X8Array#,+ writeWord8X16Array#,+ writeWord16X8Array#,+ writeWord32X4Array#,+ writeWord64X2Array#,+ writeWord8X32Array#,+ writeWord16X16Array#,+ writeWord32X8Array#,+ writeWord64X4Array#,+ writeWord8X64Array#,+ writeWord16X32Array#,+ writeWord32X16Array#,+ writeWord64X8Array#,+ writeFloatX4Array#,+ writeDoubleX2Array#,+ writeFloatX8Array#,+ writeDoubleX4Array#,+ writeFloatX16Array#,+ writeDoubleX8Array#,+ indexInt8X16OffAddr#,+ indexInt16X8OffAddr#,+ indexInt32X4OffAddr#,+ indexInt64X2OffAddr#,+ indexInt8X32OffAddr#,+ indexInt16X16OffAddr#,+ indexInt32X8OffAddr#,+ indexInt64X4OffAddr#,+ indexInt8X64OffAddr#,+ indexInt16X32OffAddr#,+ indexInt32X16OffAddr#,+ indexInt64X8OffAddr#,+ indexWord8X16OffAddr#,+ indexWord16X8OffAddr#,+ indexWord32X4OffAddr#,+ indexWord64X2OffAddr#,+ indexWord8X32OffAddr#,+ indexWord16X16OffAddr#,+ indexWord32X8OffAddr#,+ indexWord64X4OffAddr#,+ indexWord8X64OffAddr#,+ indexWord16X32OffAddr#,+ indexWord32X16OffAddr#,+ indexWord64X8OffAddr#,+ indexFloatX4OffAddr#,+ indexDoubleX2OffAddr#,+ indexFloatX8OffAddr#,+ indexDoubleX4OffAddr#,+ indexFloatX16OffAddr#,+ indexDoubleX8OffAddr#,+ readInt8X16OffAddr#,+ readInt16X8OffAddr#,+ readInt32X4OffAddr#,+ readInt64X2OffAddr#,+ readInt8X32OffAddr#,+ readInt16X16OffAddr#,+ readInt32X8OffAddr#,+ readInt64X4OffAddr#,+ readInt8X64OffAddr#,+ readInt16X32OffAddr#,+ readInt32X16OffAddr#,+ readInt64X8OffAddr#,+ readWord8X16OffAddr#,+ readWord16X8OffAddr#,+ readWord32X4OffAddr#,+ readWord64X2OffAddr#,+ readWord8X32OffAddr#,+ readWord16X16OffAddr#,+ readWord32X8OffAddr#,+ readWord64X4OffAddr#,+ readWord8X64OffAddr#,+ readWord16X32OffAddr#,+ readWord32X16OffAddr#,+ readWord64X8OffAddr#,+ readFloatX4OffAddr#,+ readDoubleX2OffAddr#,+ readFloatX8OffAddr#,+ readDoubleX4OffAddr#,+ readFloatX16OffAddr#,+ readDoubleX8OffAddr#,+ writeInt8X16OffAddr#,+ writeInt16X8OffAddr#,+ writeInt32X4OffAddr#,+ writeInt64X2OffAddr#,+ writeInt8X32OffAddr#,+ writeInt16X16OffAddr#,+ writeInt32X8OffAddr#,+ writeInt64X4OffAddr#,+ writeInt8X64OffAddr#,+ writeInt16X32OffAddr#,+ writeInt32X16OffAddr#,+ writeInt64X8OffAddr#,+ writeWord8X16OffAddr#,+ writeWord16X8OffAddr#,+ writeWord32X4OffAddr#,+ writeWord64X2OffAddr#,+ writeWord8X32OffAddr#,+ writeWord16X16OffAddr#,+ writeWord32X8OffAddr#,+ writeWord64X4OffAddr#,+ writeWord8X64OffAddr#,+ writeWord16X32OffAddr#,+ writeWord32X16OffAddr#,+ writeWord64X8OffAddr#,+ writeFloatX4OffAddr#,+ writeDoubleX2OffAddr#,+ writeFloatX8OffAddr#,+ writeDoubleX4OffAddr#,+ writeFloatX16OffAddr#,+ writeDoubleX8OffAddr#,+ indexInt8ArrayAsInt8X16#,+ indexInt16ArrayAsInt16X8#,+ indexInt32ArrayAsInt32X4#,+ indexInt64ArrayAsInt64X2#,+ indexInt8ArrayAsInt8X32#,+ indexInt16ArrayAsInt16X16#,+ indexInt32ArrayAsInt32X8#,+ indexInt64ArrayAsInt64X4#,+ indexInt8ArrayAsInt8X64#,+ indexInt16ArrayAsInt16X32#,+ indexInt32ArrayAsInt32X16#,+ indexInt64ArrayAsInt64X8#,+ indexWord8ArrayAsWord8X16#,+ indexWord16ArrayAsWord16X8#,+ indexWord32ArrayAsWord32X4#,+ indexWord64ArrayAsWord64X2#,+ indexWord8ArrayAsWord8X32#,+ indexWord16ArrayAsWord16X16#,+ indexWord32ArrayAsWord32X8#,+ indexWord64ArrayAsWord64X4#,+ indexWord8ArrayAsWord8X64#,+ indexWord16ArrayAsWord16X32#,+ indexWord32ArrayAsWord32X16#,+ indexWord64ArrayAsWord64X8#,+ indexFloatArrayAsFloatX4#,+ indexDoubleArrayAsDoubleX2#,+ indexFloatArrayAsFloatX8#,+ indexDoubleArrayAsDoubleX4#,+ indexFloatArrayAsFloatX16#,+ indexDoubleArrayAsDoubleX8#,+ readInt8ArrayAsInt8X16#,+ readInt16ArrayAsInt16X8#,+ readInt32ArrayAsInt32X4#,+ readInt64ArrayAsInt64X2#,+ readInt8ArrayAsInt8X32#,+ readInt16ArrayAsInt16X16#,+ readInt32ArrayAsInt32X8#,+ readInt64ArrayAsInt64X4#,+ readInt8ArrayAsInt8X64#,+ readInt16ArrayAsInt16X32#,+ readInt32ArrayAsInt32X16#,+ readInt64ArrayAsInt64X8#,+ readWord8ArrayAsWord8X16#,+ readWord16ArrayAsWord16X8#,+ readWord32ArrayAsWord32X4#,+ readWord64ArrayAsWord64X2#,+ readWord8ArrayAsWord8X32#,+ readWord16ArrayAsWord16X16#,+ readWord32ArrayAsWord32X8#,+ readWord64ArrayAsWord64X4#,+ readWord8ArrayAsWord8X64#,+ readWord16ArrayAsWord16X32#,+ readWord32ArrayAsWord32X16#,+ readWord64ArrayAsWord64X8#,+ readFloatArrayAsFloatX4#,+ readDoubleArrayAsDoubleX2#,+ readFloatArrayAsFloatX8#,+ readDoubleArrayAsDoubleX4#,+ readFloatArrayAsFloatX16#,+ readDoubleArrayAsDoubleX8#,+ writeInt8ArrayAsInt8X16#,+ writeInt16ArrayAsInt16X8#,+ writeInt32ArrayAsInt32X4#,+ writeInt64ArrayAsInt64X2#,+ writeInt8ArrayAsInt8X32#,+ writeInt16ArrayAsInt16X16#,+ writeInt32ArrayAsInt32X8#,+ writeInt64ArrayAsInt64X4#,+ writeInt8ArrayAsInt8X64#,+ writeInt16ArrayAsInt16X32#,+ writeInt32ArrayAsInt32X16#,+ writeInt64ArrayAsInt64X8#,+ writeWord8ArrayAsWord8X16#,+ writeWord16ArrayAsWord16X8#,+ writeWord32ArrayAsWord32X4#,+ writeWord64ArrayAsWord64X2#,+ writeWord8ArrayAsWord8X32#,+ writeWord16ArrayAsWord16X16#,+ writeWord32ArrayAsWord32X8#,+ writeWord64ArrayAsWord64X4#,+ writeWord8ArrayAsWord8X64#,+ writeWord16ArrayAsWord16X32#,+ writeWord32ArrayAsWord32X16#,+ writeWord64ArrayAsWord64X8#,+ writeFloatArrayAsFloatX4#,+ writeDoubleArrayAsDoubleX2#,+ writeFloatArrayAsFloatX8#,+ writeDoubleArrayAsDoubleX4#,+ writeFloatArrayAsFloatX16#,+ writeDoubleArrayAsDoubleX8#,+ indexInt8OffAddrAsInt8X16#,+ indexInt16OffAddrAsInt16X8#,+ indexInt32OffAddrAsInt32X4#,+ indexInt64OffAddrAsInt64X2#,+ indexInt8OffAddrAsInt8X32#,+ indexInt16OffAddrAsInt16X16#,+ indexInt32OffAddrAsInt32X8#,+ indexInt64OffAddrAsInt64X4#,+ indexInt8OffAddrAsInt8X64#,+ indexInt16OffAddrAsInt16X32#,+ indexInt32OffAddrAsInt32X16#,+ indexInt64OffAddrAsInt64X8#,+ indexWord8OffAddrAsWord8X16#,+ indexWord16OffAddrAsWord16X8#,+ indexWord32OffAddrAsWord32X4#,+ indexWord64OffAddrAsWord64X2#,+ indexWord8OffAddrAsWord8X32#,+ indexWord16OffAddrAsWord16X16#,+ indexWord32OffAddrAsWord32X8#,+ indexWord64OffAddrAsWord64X4#,+ indexWord8OffAddrAsWord8X64#,+ indexWord16OffAddrAsWord16X32#,+ indexWord32OffAddrAsWord32X16#,+ indexWord64OffAddrAsWord64X8#,+ indexFloatOffAddrAsFloatX4#,+ indexDoubleOffAddrAsDoubleX2#,+ indexFloatOffAddrAsFloatX8#,+ indexDoubleOffAddrAsDoubleX4#,+ indexFloatOffAddrAsFloatX16#,+ indexDoubleOffAddrAsDoubleX8#,+ readInt8OffAddrAsInt8X16#,+ readInt16OffAddrAsInt16X8#,+ readInt32OffAddrAsInt32X4#,+ readInt64OffAddrAsInt64X2#,+ readInt8OffAddrAsInt8X32#,+ readInt16OffAddrAsInt16X16#,+ readInt32OffAddrAsInt32X8#,+ readInt64OffAddrAsInt64X4#,+ readInt8OffAddrAsInt8X64#,+ readInt16OffAddrAsInt16X32#,+ readInt32OffAddrAsInt32X16#,+ readInt64OffAddrAsInt64X8#,+ readWord8OffAddrAsWord8X16#,+ readWord16OffAddrAsWord16X8#,+ readWord32OffAddrAsWord32X4#,+ readWord64OffAddrAsWord64X2#,+ readWord8OffAddrAsWord8X32#,+ readWord16OffAddrAsWord16X16#,+ readWord32OffAddrAsWord32X8#,+ readWord64OffAddrAsWord64X4#,+ readWord8OffAddrAsWord8X64#,+ readWord16OffAddrAsWord16X32#,+ readWord32OffAddrAsWord32X16#,+ readWord64OffAddrAsWord64X8#,+ readFloatOffAddrAsFloatX4#,+ readDoubleOffAddrAsDoubleX2#,+ readFloatOffAddrAsFloatX8#,+ readDoubleOffAddrAsDoubleX4#,+ readFloatOffAddrAsFloatX16#,+ readDoubleOffAddrAsDoubleX8#,+ writeInt8OffAddrAsInt8X16#,+ writeInt16OffAddrAsInt16X8#,+ writeInt32OffAddrAsInt32X4#,+ writeInt64OffAddrAsInt64X2#,+ writeInt8OffAddrAsInt8X32#,+ writeInt16OffAddrAsInt16X16#,+ writeInt32OffAddrAsInt32X8#,+ writeInt64OffAddrAsInt64X4#,+ writeInt8OffAddrAsInt8X64#,+ writeInt16OffAddrAsInt16X32#,+ writeInt32OffAddrAsInt32X16#,+ writeInt64OffAddrAsInt64X8#,+ writeWord8OffAddrAsWord8X16#,+ writeWord16OffAddrAsWord16X8#,+ writeWord32OffAddrAsWord32X4#,+ writeWord64OffAddrAsWord64X2#,+ writeWord8OffAddrAsWord8X32#,+ writeWord16OffAddrAsWord16X16#,+ writeWord32OffAddrAsWord32X8#,+ writeWord64OffAddrAsWord64X4#,+ writeWord8OffAddrAsWord8X64#,+ writeWord16OffAddrAsWord16X32#,+ writeWord32OffAddrAsWord32X16#,+ writeWord64OffAddrAsWord64X8#,+ writeFloatOffAddrAsFloatX4#,+ writeDoubleOffAddrAsDoubleX2#,+ writeFloatOffAddrAsFloatX8#,+ writeDoubleOffAddrAsDoubleX4#,+ writeFloatOffAddrAsFloatX16#,+ writeDoubleOffAddrAsDoubleX8#,+ +-- * Prefetch+-- |Prefetch operations: Note how every prefetch operation has a name+-- with the pattern prefetch*N#, where N is either 0,1,2, or 3.+-- +-- This suffix number, N, is the \"locality level\" of the prefetch, following the+-- convention in GCC and other compilers.+-- Higher locality numbers correspond to the memory being loaded in more+-- levels of the cpu cache, and being retained after initial use. The naming+-- convention follows the naming convention of the prefetch intrinsic found+-- in the GCC and Clang C compilers.+-- +-- On the LLVM backend, prefetch*N# uses the LLVM prefetch intrinsic+-- with locality level N. The code generated by LLVM is target architecture+-- dependent, but should agree with the GHC NCG on x86 systems.+-- +-- On the Sparc and PPC native backends, prefetch*N is a No-Op.+-- +-- On the x86 NCG, N=0 will generate prefetchNTA,+-- N=1 generates prefetcht2, N=2 generates prefetcht1, and+-- N=3 generates prefetcht0.+-- +-- For streaming workloads, the prefetch*0 operations are recommended.+-- For workloads which do many reads or writes to a memory location in a short period of time,+-- prefetch*3 operations are recommended.+-- +-- For further reading about prefetch and associated systems performance optimization,+-- the instruction set and optimization manuals by Intel and other CPU vendors are+-- excellent starting place.+-- +-- +-- The \"Intel 64 and IA-32 Architectures Optimization Reference Manual\" is+-- especially a helpful read, even if your software is meant for other CPU+-- architectures or vendor hardware. The manual can be found at+-- http:\/\/www.intel.com\/content\/www\/us\/en\/architecture-and-technology\/64-ia-32-architectures-optimization-manual.html .+-- +-- The @prefetch*@ family of operations has the order of operations+-- determined by passing around the @State#@ token.+-- +-- To get a \"pure\" version of these operations, use @inlinePerformIO@ which is quite safe in this context.+-- +-- It is important to note that while the prefetch operations will never change the+-- answer to a pure computation, They CAN change the memory locations resident+-- in a CPU cache and that may change the performance and timing characteristics+-- of an application. The prefetch operations are marked has_side_effects=True+-- to reflect that these operations have side effects with respect to the runtime+-- performance characteristics of the resulting code. Additionally, if the prefetchValue+-- operations did not have this attribute, GHC does a float out transformation that+-- results in a let\/app violation, at least with the current design.+-- +++ prefetchByteArray3#,+ prefetchMutableByteArray3#,+ prefetchAddr3#,+ prefetchValue3#,+ prefetchByteArray2#,+ prefetchMutableByteArray2#,+ prefetchAddr2#,+ prefetchValue2#,+ prefetchByteArray1#,+ prefetchMutableByteArray1#,+ prefetchAddr1#,+ prefetchValue1#,+ prefetchByteArray0#,+ prefetchMutableByteArray0#,+ prefetchAddr0#,+ prefetchValue0#,+) where++{-+has_side_effects = False+out_of_line = False+can_fail = False+commutable = False+code_size = { primOpCodeSizeDefault }+strictness = { \ arity -> mkClosedStrictSig (replicate arity topDmd) topRes }+fixity = Nothing+llvm_only = False++-}+import GHC.Types (Coercible)++data Char#++gtChar# :: Char# -> Char# -> Int#+gtChar# = let x = x in x++geChar# :: Char# -> Char# -> Int#+geChar# = let x = x in x++eqChar# :: Char# -> Char# -> Int#+eqChar# = let x = x in x++neChar# :: Char# -> Char# -> Int#+neChar# = let x = x in x++ltChar# :: Char# -> Char# -> Int#+ltChar# = let x = x in x++leChar# :: Char# -> Char# -> Int#+leChar# = let x = x in x++ord# :: Char# -> Int#+ord# = let x = x in x++data Int#++infixl 6 +#+(+#) :: Int# -> Int# -> Int#+(+#) = let x = x in x++infixl 6 -#+(-#) :: Int# -> Int# -> Int#+(-#) = let x = x in x++-- |Low word of signed integer multiply.++infixl 7 *#+(*#) :: Int# -> Int# -> Int#+(*#) = let x = x in x++-- |Return non-zero if there is any possibility that the upper word of a+-- signed integer multiply might contain useful information. Return+-- zero only if you are completely sure that no overflow can occur.+-- On a 32-bit platform, the recommmended implementation is to do a+-- 32 x 32 -> 64 signed multiply, and subtract result[63:32] from+-- (result[31] >>signed 31). If this is zero, meaning that the+-- upper word is merely a sign extension of the lower one, no+-- overflow can occur.+-- +-- On a 64-bit platform it is not always possible to+-- acquire the top 64 bits of the result. Therefore, a recommended+-- implementation is to take the absolute value of both operands, and+-- return 0 iff bits[63:31] of them are zero, since that means that their+-- magnitudes fit within 31 bits, so the magnitude of the product must fit+-- into 62 bits.+-- +-- If in doubt, return non-zero, but do make an effort to create the+-- correct answer for small args, since otherwise the performance of+-- @(*) :: Integer -> Integer -> Integer@ will be poor.+-- ++mulIntMayOflo# :: Int# -> Int# -> Int#+mulIntMayOflo# = let x = x in x++-- |Rounds towards zero.++quotInt# :: Int# -> Int# -> Int#+quotInt# = let x = x in x++-- |Satisfies @(quotInt\# x y) *\# y +\# (remInt\# x y) == x@.++remInt# :: Int# -> Int# -> Int#+remInt# = let x = x in x++-- |Rounds towards zero.++quotRemInt# :: Int# -> Int# -> (# Int#,Int# #)+quotRemInt# = let x = x in x++andI# :: Int# -> Int# -> Int#+andI# = let x = x in x++orI# :: Int# -> Int# -> Int#+orI# = let x = x in x++xorI# :: Int# -> Int# -> Int#+xorI# = let x = x in x++notI# :: Int# -> Int#+notI# = let x = x in x++negateInt# :: Int# -> Int#+negateInt# = let x = x in x++-- |Add signed integers reporting overflow.+-- First member of result is the sum truncated to an @Int#@;+-- second member is zero if the true sum fits in an @Int#@,+-- nonzero if overflow occurred (the sum is either too large+-- or too small to fit in an @Int#@).++addIntC# :: Int# -> Int# -> (# Int#,Int# #)+addIntC# = let x = x in x++-- |Subtract signed integers reporting overflow.+-- First member of result is the difference truncated to an @Int#@;+-- second member is zero if the true difference fits in an @Int#@,+-- nonzero if overflow occurred (the difference is either too large+-- or too small to fit in an @Int#@).++subIntC# :: Int# -> Int# -> (# Int#,Int# #)+subIntC# = let x = x in x++infix 4 >#+(>#) :: Int# -> Int# -> Int#+(>#) = let x = x in x++infix 4 >=#+(>=#) :: Int# -> Int# -> Int#+(>=#) = let x = x in x++infix 4 ==#+(==#) :: Int# -> Int# -> Int#+(==#) = let x = x in x++infix 4 /=#+(/=#) :: Int# -> Int# -> Int#+(/=#) = let x = x in x++infix 4 <#+(<#) :: Int# -> Int# -> Int#+(<#) = let x = x in x++infix 4 <=#+(<=#) :: Int# -> Int# -> Int#+(<=#) = let x = x in x++chr# :: Int# -> Char#+chr# = let x = x in x++int2Word# :: Int# -> Word#+int2Word# = let x = x in x++int2Float# :: Int# -> Float#+int2Float# = let x = x in x++int2Double# :: Int# -> Double#+int2Double# = let x = x in x++word2Float# :: Word# -> Float#+word2Float# = let x = x in x++word2Double# :: Word# -> Double#+word2Double# = let x = x in x++-- |Shift left. Result undefined if shift amount is not+-- in the range 0 to word size - 1 inclusive.++uncheckedIShiftL# :: Int# -> Int# -> Int#+uncheckedIShiftL# = let x = x in x++-- |Shift right arithmetic. Result undefined if shift amount is not+-- in the range 0 to word size - 1 inclusive.++uncheckedIShiftRA# :: Int# -> Int# -> Int#+uncheckedIShiftRA# = let x = x in x++-- |Shift right logical. Result undefined if shift amount is not+-- in the range 0 to word size - 1 inclusive.++uncheckedIShiftRL# :: Int# -> Int# -> Int#+uncheckedIShiftRL# = let x = x in x++data Word#++plusWord# :: Word# -> Word# -> Word#+plusWord# = let x = x in x++plusWord2# :: Word# -> Word# -> (# Word#,Word# #)+plusWord2# = let x = x in x++minusWord# :: Word# -> Word# -> Word#+minusWord# = let x = x in x++timesWord# :: Word# -> Word# -> Word#+timesWord# = let x = x in x++timesWord2# :: Word# -> Word# -> (# Word#,Word# #)+timesWord2# = let x = x in x++quotWord# :: Word# -> Word# -> Word#+quotWord# = let x = x in x++remWord# :: Word# -> Word# -> Word#+remWord# = let x = x in x++quotRemWord# :: Word# -> Word# -> (# Word#,Word# #)+quotRemWord# = let x = x in x++quotRemWord2# :: Word# -> Word# -> Word# -> (# Word#,Word# #)+quotRemWord2# = let x = x in x++and# :: Word# -> Word# -> Word#+and# = let x = x in x++or# :: Word# -> Word# -> Word#+or# = let x = x in x++xor# :: Word# -> Word# -> Word#+xor# = let x = x in x++not# :: Word# -> Word#+not# = let x = x in x++-- |Shift left logical. Result undefined if shift amount is not+-- in the range 0 to word size - 1 inclusive.++uncheckedShiftL# :: Word# -> Int# -> Word#+uncheckedShiftL# = let x = x in x++-- |Shift right logical. Result undefined if shift amount is not+-- in the range 0 to word size - 1 inclusive.++uncheckedShiftRL# :: Word# -> Int# -> Word#+uncheckedShiftRL# = let x = x in x++word2Int# :: Word# -> Int#+word2Int# = let x = x in x++gtWord# :: Word# -> Word# -> Int#+gtWord# = let x = x in x++geWord# :: Word# -> Word# -> Int#+geWord# = let x = x in x++eqWord# :: Word# -> Word# -> Int#+eqWord# = let x = x in x++neWord# :: Word# -> Word# -> Int#+neWord# = let x = x in x++ltWord# :: Word# -> Word# -> Int#+ltWord# = let x = x in x++leWord# :: Word# -> Word# -> Int#+leWord# = let x = x in x++-- |Count the number of set bits in the lower 8 bits of a word.++popCnt8# :: Word# -> Word#+popCnt8# = let x = x in x++-- |Count the number of set bits in the lower 16 bits of a word.++popCnt16# :: Word# -> Word#+popCnt16# = let x = x in x++-- |Count the number of set bits in the lower 32 bits of a word.++popCnt32# :: Word# -> Word#+popCnt32# = let x = x in x++-- |Count the number of set bits in a 64-bit word.++popCnt64# :: Word# -> Word#+popCnt64# = let x = x in x++-- |Count the number of set bits in a word.++popCnt# :: Word# -> Word#+popCnt# = let x = x in x++-- |Count leading zeros in the lower 8 bits of a word.++clz8# :: Word# -> Word#+clz8# = let x = x in x++-- |Count leading zeros in the lower 16 bits of a word.++clz16# :: Word# -> Word#+clz16# = let x = x in x++-- |Count leading zeros in the lower 32 bits of a word.++clz32# :: Word# -> Word#+clz32# = let x = x in x++-- |Count leading zeros in a 64-bit word.++clz64# :: Word# -> Word#+clz64# = let x = x in x++-- |Count leading zeros in a word.++clz# :: Word# -> Word#+clz# = let x = x in x++-- |Count trailing zeros in the lower 8 bits of a word.++ctz8# :: Word# -> Word#+ctz8# = let x = x in x++-- |Count trailing zeros in the lower 16 bits of a word.++ctz16# :: Word# -> Word#+ctz16# = let x = x in x++-- |Count trailing zeros in the lower 32 bits of a word.++ctz32# :: Word# -> Word#+ctz32# = let x = x in x++-- |Count trailing zeros in a 64-bit word.++ctz64# :: Word# -> Word#+ctz64# = let x = x in x++-- |Count trailing zeros in a word.++ctz# :: Word# -> Word#+ctz# = let x = x in x++-- |Swap bytes in the lower 16 bits of a word. The higher bytes are undefined. ++byteSwap16# :: Word# -> Word#+byteSwap16# = let x = x in x++-- |Swap bytes in the lower 32 bits of a word. The higher bytes are undefined. ++byteSwap32# :: Word# -> Word#+byteSwap32# = let x = x in x++-- |Swap bytes in a 64 bits of a word.++byteSwap64# :: Word# -> Word#+byteSwap64# = let x = x in x++-- |Swap bytes in a word.++byteSwap# :: Word# -> Word#+byteSwap# = let x = x in x++narrow8Int# :: Int# -> Int#+narrow8Int# = let x = x in x++narrow16Int# :: Int# -> Int#+narrow16Int# = let x = x in x++narrow32Int# :: Int# -> Int#+narrow32Int# = let x = x in x++narrow8Word# :: Word# -> Word#+narrow8Word# = let x = x in x++narrow16Word# :: Word# -> Word#+narrow16Word# = let x = x in x++narrow32Word# :: Word# -> Word#+narrow32Word# = let x = x in x++data Double#++infix 4 >##+(>##) :: Double# -> Double# -> Int#+(>##) = let x = x in x++infix 4 >=##+(>=##) :: Double# -> Double# -> Int#+(>=##) = let x = x in x++infix 4 ==##+(==##) :: Double# -> Double# -> Int#+(==##) = let x = x in x++infix 4 /=##+(/=##) :: Double# -> Double# -> Int#+(/=##) = let x = x in x++infix 4 <##+(<##) :: Double# -> Double# -> Int#+(<##) = let x = x in x++infix 4 <=##+(<=##) :: Double# -> Double# -> Int#+(<=##) = let x = x in x++infixl 6 +##+(+##) :: Double# -> Double# -> Double#+(+##) = let x = x in x++infixl 6 -##+(-##) :: Double# -> Double# -> Double#+(-##) = let x = x in x++infixl 7 *##+(*##) :: Double# -> Double# -> Double#+(*##) = let x = x in x++infixl 7 /##+(/##) :: Double# -> Double# -> Double#+(/##) = let x = x in x++negateDouble# :: Double# -> Double#+negateDouble# = let x = x in x++-- |Truncates a @Double#@ value to the nearest @Int#@.+-- Results are undefined if the truncation if truncation yields+-- a value outside the range of @Int#@.++double2Int# :: Double# -> Int#+double2Int# = let x = x in x++double2Float# :: Double# -> Float#+double2Float# = let x = x in x++expDouble# :: Double# -> Double#+expDouble# = let x = x in x++logDouble# :: Double# -> Double#+logDouble# = let x = x in x++sqrtDouble# :: Double# -> Double#+sqrtDouble# = let x = x in x++sinDouble# :: Double# -> Double#+sinDouble# = let x = x in x++cosDouble# :: Double# -> Double#+cosDouble# = let x = x in x++tanDouble# :: Double# -> Double#+tanDouble# = let x = x in x++asinDouble# :: Double# -> Double#+asinDouble# = let x = x in x++acosDouble# :: Double# -> Double#+acosDouble# = let x = x in x++atanDouble# :: Double# -> Double#+atanDouble# = let x = x in x++sinhDouble# :: Double# -> Double#+sinhDouble# = let x = x in x++coshDouble# :: Double# -> Double#+coshDouble# = let x = x in x++tanhDouble# :: Double# -> Double#+tanhDouble# = let x = x in x++-- |Exponentiation.++(**##) :: Double# -> Double# -> Double#+(**##) = let x = x in x++-- |Convert to integer.+-- First component of the result is -1 or 1, indicating the sign of the+-- mantissa. The next two are the high and low 32 bits of the mantissa+-- respectively, and the last is the exponent.++decodeDouble_2Int# :: Double# -> (# Int#,Word#,Word#,Int# #)+decodeDouble_2Int# = let x = x in x++-- |Decode @Double\#@ into mantissa and base-2 exponent.++decodeDouble_Int64# :: Double# -> (# Int#,Int# #)+decodeDouble_Int64# = let x = x in x++data Float#++gtFloat# :: Float# -> Float# -> Int#+gtFloat# = let x = x in x++geFloat# :: Float# -> Float# -> Int#+geFloat# = let x = x in x++eqFloat# :: Float# -> Float# -> Int#+eqFloat# = let x = x in x++neFloat# :: Float# -> Float# -> Int#+neFloat# = let x = x in x++ltFloat# :: Float# -> Float# -> Int#+ltFloat# = let x = x in x++leFloat# :: Float# -> Float# -> Int#+leFloat# = let x = x in x++plusFloat# :: Float# -> Float# -> Float#+plusFloat# = let x = x in x++minusFloat# :: Float# -> Float# -> Float#+minusFloat# = let x = x in x++timesFloat# :: Float# -> Float# -> Float#+timesFloat# = let x = x in x++divideFloat# :: Float# -> Float# -> Float#+divideFloat# = let x = x in x++negateFloat# :: Float# -> Float#+negateFloat# = let x = x in x++-- |Truncates a @Float#@ value to the nearest @Int#@.+-- Results are undefined if the truncation if truncation yields+-- a value outside the range of @Int#@.++float2Int# :: Float# -> Int#+float2Int# = let x = x in x++expFloat# :: Float# -> Float#+expFloat# = let x = x in x++logFloat# :: Float# -> Float#+logFloat# = let x = x in x++sqrtFloat# :: Float# -> Float#+sqrtFloat# = let x = x in x++sinFloat# :: Float# -> Float#+sinFloat# = let x = x in x++cosFloat# :: Float# -> Float#+cosFloat# = let x = x in x++tanFloat# :: Float# -> Float#+tanFloat# = let x = x in x++asinFloat# :: Float# -> Float#+asinFloat# = let x = x in x++acosFloat# :: Float# -> Float#+acosFloat# = let x = x in x++atanFloat# :: Float# -> Float#+atanFloat# = let x = x in x++sinhFloat# :: Float# -> Float#+sinhFloat# = let x = x in x++coshFloat# :: Float# -> Float#+coshFloat# = let x = x in x++tanhFloat# :: Float# -> Float#+tanhFloat# = let x = x in x++powerFloat# :: Float# -> Float# -> Float#+powerFloat# = let x = x in x++float2Double# :: Float# -> Double#+float2Double# = let x = x in x++-- |Convert to integers.+-- First @Int\#@ in result is the mantissa; second is the exponent.++decodeFloat_Int# :: Float# -> (# Int#,Int# #)+decodeFloat_Int# = let x = x in x++data Array# a++data MutableArray# s a++-- |Create a new mutable array with the specified number of elements,+-- in the specified state thread,+-- with each element containing the specified initial value.++newArray# :: Int# -> a -> State# s -> (# State# s,MutableArray# s a #)+newArray# = let x = x in x++sameMutableArray# :: MutableArray# s a -> MutableArray# s a -> Int#+sameMutableArray# = let x = x in x++-- |Read from specified index of mutable array. Result is not yet evaluated.++readArray# :: MutableArray# s a -> Int# -> State# s -> (# State# s,a #)+readArray# = let x = x in x++-- |Write to specified index of mutable array.++writeArray# :: MutableArray# s a -> Int# -> a -> State# s -> State# s+writeArray# = let x = x in x++-- |Return the number of elements in the array.++sizeofArray# :: Array# a -> Int#+sizeofArray# = let x = x in x++-- |Return the number of elements in the array.++sizeofMutableArray# :: MutableArray# s a -> Int#+sizeofMutableArray# = let x = x in x++-- |Read from specified index of immutable array. Result is packaged into+-- an unboxed singleton; the result itself is not yet evaluated.++indexArray# :: Array# a -> Int# -> (# a #)+indexArray# = let x = x in x++-- |Make a mutable array immutable, without copying.++unsafeFreezeArray# :: MutableArray# s a -> State# s -> (# State# s,Array# a #)+unsafeFreezeArray# = let x = x in x++-- |Make an immutable array mutable, without copying.++unsafeThawArray# :: Array# a -> State# s -> (# State# s,MutableArray# s a #)+unsafeThawArray# = let x = x in x++-- |Given a source array, an offset into the source array, a+-- destination array, an offset into the destination array, and a+-- number of elements to copy, copy the elements from the source array+-- to the destination array. Both arrays must fully contain the+-- specified ranges, but this is not checked. The two arrays must not+-- be the same array in different states, but this is not checked+-- either.++copyArray# :: Array# a -> Int# -> MutableArray# s a -> Int# -> Int# -> State# s -> State# s+copyArray# = let x = x in x++-- |Given a source array, an offset into the source array, a+-- destination array, an offset into the destination array, and a+-- number of elements to copy, copy the elements from the source array+-- to the destination array. The source and destination arrays can+-- refer to the same array. Both arrays must fully contain the+-- specified ranges, but this is not checked.++copyMutableArray# :: MutableArray# s a -> Int# -> MutableArray# s a -> Int# -> Int# -> State# s -> State# s+copyMutableArray# = let x = x in x++-- |Given a source array, an offset into the source array, and a number+-- of elements to copy, create a new array with the elements from the+-- source array. The provided array must fully contain the specified+-- range, but this is not checked.++cloneArray# :: Array# a -> Int# -> Int# -> Array# a+cloneArray# = let x = x in x++-- |Given a source array, an offset into the source array, and a number+-- of elements to copy, create a new array with the elements from the+-- source array. The provided array must fully contain the specified+-- range, but this is not checked.++cloneMutableArray# :: MutableArray# s a -> Int# -> Int# -> State# s -> (# State# s,MutableArray# s a #)+cloneMutableArray# = let x = x in x++-- |Given a source array, an offset into the source array, and a number+-- of elements to copy, create a new array with the elements from the+-- source array. The provided array must fully contain the specified+-- range, but this is not checked.++freezeArray# :: MutableArray# s a -> Int# -> Int# -> State# s -> (# State# s,Array# a #)+freezeArray# = let x = x in x++-- |Given a source array, an offset into the source array, and a number+-- of elements to copy, create a new array with the elements from the+-- source array. The provided array must fully contain the specified+-- range, but this is not checked.++thawArray# :: Array# a -> Int# -> Int# -> State# s -> (# State# s,MutableArray# s a #)+thawArray# = let x = x in x++-- |Unsafe, machine-level atomic compare and swap on an element within an Array.++casArray# :: MutableArray# s a -> Int# -> a -> a -> State# s -> (# State# s,Int#,a #)+casArray# = let x = x in x++data SmallArray# a++data SmallMutableArray# s a++-- |Create a new mutable array with the specified number of elements,+-- in the specified state thread,+-- with each element containing the specified initial value.++newSmallArray# :: Int# -> a -> State# s -> (# State# s,SmallMutableArray# s a #)+newSmallArray# = let x = x in x++sameSmallMutableArray# :: SmallMutableArray# s a -> SmallMutableArray# s a -> Int#+sameSmallMutableArray# = let x = x in x++-- |Read from specified index of mutable array. Result is not yet evaluated.++readSmallArray# :: SmallMutableArray# s a -> Int# -> State# s -> (# State# s,a #)+readSmallArray# = let x = x in x++-- |Write to specified index of mutable array.++writeSmallArray# :: SmallMutableArray# s a -> Int# -> a -> State# s -> State# s+writeSmallArray# = let x = x in x++-- |Return the number of elements in the array.++sizeofSmallArray# :: SmallArray# a -> Int#+sizeofSmallArray# = let x = x in x++-- |Return the number of elements in the array.++sizeofSmallMutableArray# :: SmallMutableArray# s a -> Int#+sizeofSmallMutableArray# = let x = x in x++-- |Read from specified index of immutable array. Result is packaged into+-- an unboxed singleton; the result itself is not yet evaluated.++indexSmallArray# :: SmallArray# a -> Int# -> (# a #)+indexSmallArray# = let x = x in x++-- |Make a mutable array immutable, without copying.++unsafeFreezeSmallArray# :: SmallMutableArray# s a -> State# s -> (# State# s,SmallArray# a #)+unsafeFreezeSmallArray# = let x = x in x++-- |Make an immutable array mutable, without copying.++unsafeThawSmallArray# :: SmallArray# a -> State# s -> (# State# s,SmallMutableArray# s a #)+unsafeThawSmallArray# = let x = x in x++-- |Given a source array, an offset into the source array, a+-- destination array, an offset into the destination array, and a+-- number of elements to copy, copy the elements from the source array+-- to the destination array. Both arrays must fully contain the+-- specified ranges, but this is not checked. The two arrays must not+-- be the same array in different states, but this is not checked+-- either.++copySmallArray# :: SmallArray# a -> Int# -> SmallMutableArray# s a -> Int# -> Int# -> State# s -> State# s+copySmallArray# = let x = x in x++-- |Given a source array, an offset into the source array, a+-- destination array, an offset into the destination array, and a+-- number of elements to copy, copy the elements from the source array+-- to the destination array. The source and destination arrays can+-- refer to the same array. Both arrays must fully contain the+-- specified ranges, but this is not checked.++copySmallMutableArray# :: SmallMutableArray# s a -> Int# -> SmallMutableArray# s a -> Int# -> Int# -> State# s -> State# s+copySmallMutableArray# = let x = x in x++-- |Given a source array, an offset into the source array, and a number+-- of elements to copy, create a new array with the elements from the+-- source array. The provided array must fully contain the specified+-- range, but this is not checked.++cloneSmallArray# :: SmallArray# a -> Int# -> Int# -> SmallArray# a+cloneSmallArray# = let x = x in x++-- |Given a source array, an offset into the source array, and a number+-- of elements to copy, create a new array with the elements from the+-- source array. The provided array must fully contain the specified+-- range, but this is not checked.++cloneSmallMutableArray# :: SmallMutableArray# s a -> Int# -> Int# -> State# s -> (# State# s,SmallMutableArray# s a #)+cloneSmallMutableArray# = let x = x in x++-- |Given a source array, an offset into the source array, and a number+-- of elements to copy, create a new array with the elements from the+-- source array. The provided array must fully contain the specified+-- range, but this is not checked.++freezeSmallArray# :: SmallMutableArray# s a -> Int# -> Int# -> State# s -> (# State# s,SmallArray# a #)+freezeSmallArray# = let x = x in x++-- |Given a source array, an offset into the source array, and a number+-- of elements to copy, create a new array with the elements from the+-- source array. The provided array must fully contain the specified+-- range, but this is not checked.++thawSmallArray# :: SmallArray# a -> Int# -> Int# -> State# s -> (# State# s,SmallMutableArray# s a #)+thawSmallArray# = let x = x in x++-- |Unsafe, machine-level atomic compare and swap on an element within an array.++casSmallArray# :: SmallMutableArray# s a -> Int# -> a -> a -> State# s -> (# State# s,Int#,a #)+casSmallArray# = let x = x in x++data ByteArray#++data MutableByteArray# s++-- |Create a new mutable byte array of specified size (in bytes), in+-- the specified state thread.++newByteArray# :: Int# -> State# s -> (# State# s,MutableByteArray# s #)+newByteArray# = let x = x in x++-- |Create a mutable byte array that the GC guarantees not to move.++newPinnedByteArray# :: Int# -> State# s -> (# State# s,MutableByteArray# s #)+newPinnedByteArray# = let x = x in x++-- |Create a mutable byte array, aligned by the specified amount, that the GC guarantees not to move.++newAlignedPinnedByteArray# :: Int# -> Int# -> State# s -> (# State# s,MutableByteArray# s #)+newAlignedPinnedByteArray# = let x = x in x++-- |Intended for use with pinned arrays; otherwise very unsafe!++byteArrayContents# :: ByteArray# -> Addr#+byteArrayContents# = let x = x in x++sameMutableByteArray# :: MutableByteArray# s -> MutableByteArray# s -> Int#+sameMutableByteArray# = let x = x in x++-- |Shrink mutable byte array to new specified size (in bytes), in+-- the specified state thread. The new size argument must be less than or+-- equal to the current size as reported by @sizeofMutableArray\#@.++shrinkMutableByteArray# :: MutableByteArray# s -> Int# -> State# s -> State# s+shrinkMutableByteArray# = let x = x in x++-- |Resize (unpinned) mutable byte array to new specified size (in bytes).+-- The returned @MutableByteArray\#@ is either the original+-- @MutableByteArray\#@ resized in-place or, if not possible, a newly+-- allocated (unpinned) @MutableByteArray\#@ (with the original content+-- copied over).+-- +-- To avoid undefined behaviour, the original @MutableByteArray\#@ shall+-- not be accessed anymore after a @resizeMutableByteArray\#@ has been+-- performed. Moreover, no reference to the old one should be kept in order+-- to allow garbage collection of the original @MutableByteArray\#@ in+-- case a new @MutableByteArray\#@ had to be allocated.++resizeMutableByteArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,MutableByteArray# s #)+resizeMutableByteArray# = let x = x in x++-- |Make a mutable byte array immutable, without copying.++unsafeFreezeByteArray# :: MutableByteArray# s -> State# s -> (# State# s,ByteArray# #)+unsafeFreezeByteArray# = let x = x in x++-- |Return the size of the array in bytes.++sizeofByteArray# :: ByteArray# -> Int#+sizeofByteArray# = let x = x in x++-- |Return the size of the array in bytes.++sizeofMutableByteArray# :: MutableByteArray# s -> Int#+sizeofMutableByteArray# = let x = x in x++-- |Read 8-bit character; offset in bytes.++indexCharArray# :: ByteArray# -> Int# -> Char#+indexCharArray# = let x = x in x++-- |Read 31-bit character; offset in 4-byte words.++indexWideCharArray# :: ByteArray# -> Int# -> Char#+indexWideCharArray# = let x = x in x++indexIntArray# :: ByteArray# -> Int# -> Int#+indexIntArray# = let x = x in x++indexWordArray# :: ByteArray# -> Int# -> Word#+indexWordArray# = let x = x in x++indexAddrArray# :: ByteArray# -> Int# -> Addr#+indexAddrArray# = let x = x in x++indexFloatArray# :: ByteArray# -> Int# -> Float#+indexFloatArray# = let x = x in x++indexDoubleArray# :: ByteArray# -> Int# -> Double#+indexDoubleArray# = let x = x in x++indexStablePtrArray# :: ByteArray# -> Int# -> StablePtr# a+indexStablePtrArray# = let x = x in x++-- |Read 8-bit integer; offset in bytes.++indexInt8Array# :: ByteArray# -> Int# -> Int#+indexInt8Array# = let x = x in x++-- |Read 16-bit integer; offset in 16-bit words.++indexInt16Array# :: ByteArray# -> Int# -> Int#+indexInt16Array# = let x = x in x++-- |Read 32-bit integer; offset in 32-bit words.++indexInt32Array# :: ByteArray# -> Int# -> Int#+indexInt32Array# = let x = x in x++-- |Read 64-bit integer; offset in 64-bit words.++indexInt64Array# :: ByteArray# -> Int# -> Int#+indexInt64Array# = let x = x in x++-- |Read 8-bit word; offset in bytes.++indexWord8Array# :: ByteArray# -> Int# -> Word#+indexWord8Array# = let x = x in x++-- |Read 16-bit word; offset in 16-bit words.++indexWord16Array# :: ByteArray# -> Int# -> Word#+indexWord16Array# = let x = x in x++-- |Read 32-bit word; offset in 32-bit words.++indexWord32Array# :: ByteArray# -> Int# -> Word#+indexWord32Array# = let x = x in x++-- |Read 64-bit word; offset in 64-bit words.++indexWord64Array# :: ByteArray# -> Int# -> Word#+indexWord64Array# = let x = x in x++-- |Read 8-bit character; offset in bytes.++readCharArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Char# #)+readCharArray# = let x = x in x++-- |Read 31-bit character; offset in 4-byte words.++readWideCharArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Char# #)+readWideCharArray# = let x = x in x++-- |Read intger; offset in words.++readIntArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int# #)+readIntArray# = let x = x in x++-- |Read word; offset in words.++readWordArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word# #)+readWordArray# = let x = x in x++readAddrArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Addr# #)+readAddrArray# = let x = x in x++readFloatArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Float# #)+readFloatArray# = let x = x in x++readDoubleArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Double# #)+readDoubleArray# = let x = x in x++readStablePtrArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,StablePtr# a #)+readStablePtrArray# = let x = x in x++readInt8Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int# #)+readInt8Array# = let x = x in x++readInt16Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int# #)+readInt16Array# = let x = x in x++readInt32Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int# #)+readInt32Array# = let x = x in x++readInt64Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int# #)+readInt64Array# = let x = x in x++readWord8Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word# #)+readWord8Array# = let x = x in x++readWord16Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word# #)+readWord16Array# = let x = x in x++readWord32Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word# #)+readWord32Array# = let x = x in x++readWord64Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word# #)+readWord64Array# = let x = x in x++-- |Write 8-bit character; offset in bytes.++writeCharArray# :: MutableByteArray# s -> Int# -> Char# -> State# s -> State# s+writeCharArray# = let x = x in x++-- |Write 31-bit character; offset in 4-byte words.++writeWideCharArray# :: MutableByteArray# s -> Int# -> Char# -> State# s -> State# s+writeWideCharArray# = let x = x in x++writeIntArray# :: MutableByteArray# s -> Int# -> Int# -> State# s -> State# s+writeIntArray# = let x = x in x++writeWordArray# :: MutableByteArray# s -> Int# -> Word# -> State# s -> State# s+writeWordArray# = let x = x in x++writeAddrArray# :: MutableByteArray# s -> Int# -> Addr# -> State# s -> State# s+writeAddrArray# = let x = x in x++writeFloatArray# :: MutableByteArray# s -> Int# -> Float# -> State# s -> State# s+writeFloatArray# = let x = x in x++writeDoubleArray# :: MutableByteArray# s -> Int# -> Double# -> State# s -> State# s+writeDoubleArray# = let x = x in x++writeStablePtrArray# :: MutableByteArray# s -> Int# -> StablePtr# a -> State# s -> State# s+writeStablePtrArray# = let x = x in x++writeInt8Array# :: MutableByteArray# s -> Int# -> Int# -> State# s -> State# s+writeInt8Array# = let x = x in x++writeInt16Array# :: MutableByteArray# s -> Int# -> Int# -> State# s -> State# s+writeInt16Array# = let x = x in x++writeInt32Array# :: MutableByteArray# s -> Int# -> Int# -> State# s -> State# s+writeInt32Array# = let x = x in x++writeInt64Array# :: MutableByteArray# s -> Int# -> Int# -> State# s -> State# s+writeInt64Array# = let x = x in x++writeWord8Array# :: MutableByteArray# s -> Int# -> Word# -> State# s -> State# s+writeWord8Array# = let x = x in x++writeWord16Array# :: MutableByteArray# s -> Int# -> Word# -> State# s -> State# s+writeWord16Array# = let x = x in x++writeWord32Array# :: MutableByteArray# s -> Int# -> Word# -> State# s -> State# s+writeWord32Array# = let x = x in x++writeWord64Array# :: MutableByteArray# s -> Int# -> Word# -> State# s -> State# s+writeWord64Array# = let x = x in x++-- |Copy a range of the ByteArray# to the specified region in the MutableByteArray#.+-- Both arrays must fully contain the specified ranges, but this is not checked.+-- The two arrays must not be the same array in different states, but this is not checked either.++copyByteArray# :: ByteArray# -> Int# -> MutableByteArray# s -> Int# -> Int# -> State# s -> State# s+copyByteArray# = let x = x in x++-- |Copy a range of the first MutableByteArray# to the specified region in the second MutableByteArray#.+-- Both arrays must fully contain the specified ranges, but this is not checked.++copyMutableByteArray# :: MutableByteArray# s -> Int# -> MutableByteArray# s -> Int# -> Int# -> State# s -> State# s+copyMutableByteArray# = let x = x in x++-- |Copy a range of the ByteArray# to the memory range starting at the Addr#.+-- The ByteArray# and the memory region at Addr# must fully contain the+-- specified ranges, but this is not checked. The Addr# must not point into the+-- ByteArray# (e.g. if the ByteArray# were pinned), but this is not checked+-- either.++copyByteArrayToAddr# :: ByteArray# -> Int# -> Addr# -> Int# -> State# s -> State# s+copyByteArrayToAddr# = let x = x in x++-- |Copy a range of the MutableByteArray# to the memory range starting at the+-- Addr#. The MutableByteArray# and the memory region at Addr# must fully+-- contain the specified ranges, but this is not checked. The Addr# must not+-- point into the MutableByteArray# (e.g. if the MutableByteArray# were+-- pinned), but this is not checked either.++copyMutableByteArrayToAddr# :: MutableByteArray# s -> Int# -> Addr# -> Int# -> State# s -> State# s+copyMutableByteArrayToAddr# = let x = x in x++-- |Copy a memory range starting at the Addr# to the specified range in the+-- MutableByteArray#. The memory region at Addr# and the ByteArray# must fully+-- contain the specified ranges, but this is not checked. The Addr# must not+-- point into the MutableByteArray# (e.g. if the MutableByteArray# were pinned),+-- but this is not checked either.++copyAddrToByteArray# :: Addr# -> MutableByteArray# s -> Int# -> Int# -> State# s -> State# s+copyAddrToByteArray# = let x = x in x++-- |Set the range of the MutableByteArray# to the specified character.++setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Int# -> State# s -> State# s+setByteArray# = let x = x in x++-- |Given an array and an offset in Int units, read an element. The+-- index is assumed to be in bounds. Implies a full memory barrier.++atomicReadIntArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int# #)+atomicReadIntArray# = let x = x in x++-- |Given an array and an offset in Int units, write an element. The+-- index is assumed to be in bounds. Implies a full memory barrier.++atomicWriteIntArray# :: MutableByteArray# s -> Int# -> Int# -> State# s -> State# s+atomicWriteIntArray# = let x = x in x++-- |Given an array, an offset in Int units, the expected old value, and+-- the new value, perform an atomic compare and swap i.e. write the new+-- value if the current value matches the provided old value. Returns+-- the value of the element before the operation. Implies a full memory+-- barrier.++casIntArray# :: MutableByteArray# s -> Int# -> Int# -> Int# -> State# s -> (# State# s,Int# #)+casIntArray# = let x = x in x++-- |Given an array, and offset in Int units, and a value to add,+-- atomically add the value to the element. Returns the value of the+-- element before the operation. Implies a full memory barrier.++fetchAddIntArray# :: MutableByteArray# s -> Int# -> Int# -> State# s -> (# State# s,Int# #)+fetchAddIntArray# = let x = x in x++-- |Given an array, and offset in Int units, and a value to subtract,+-- atomically substract the value to the element. Returns the value of+-- the element before the operation. Implies a full memory barrier.++fetchSubIntArray# :: MutableByteArray# s -> Int# -> Int# -> State# s -> (# State# s,Int# #)+fetchSubIntArray# = let x = x in x++-- |Given an array, and offset in Int units, and a value to AND,+-- atomically AND the value to the element. Returns the value of the+-- element before the operation. Implies a full memory barrier.++fetchAndIntArray# :: MutableByteArray# s -> Int# -> Int# -> State# s -> (# State# s,Int# #)+fetchAndIntArray# = let x = x in x++-- |Given an array, and offset in Int units, and a value to NAND,+-- atomically NAND the value to the element. Returns the value of the+-- element before the operation. Implies a full memory barrier.++fetchNandIntArray# :: MutableByteArray# s -> Int# -> Int# -> State# s -> (# State# s,Int# #)+fetchNandIntArray# = let x = x in x++-- |Given an array, and offset in Int units, and a value to OR,+-- atomically OR the value to the element. Returns the value of the+-- element before the operation. Implies a full memory barrier.++fetchOrIntArray# :: MutableByteArray# s -> Int# -> Int# -> State# s -> (# State# s,Int# #)+fetchOrIntArray# = let x = x in x++-- |Given an array, and offset in Int units, and a value to XOR,+-- atomically XOR the value to the element. Returns the value of the+-- element before the operation. Implies a full memory barrier.++fetchXorIntArray# :: MutableByteArray# s -> Int# -> Int# -> State# s -> (# State# s,Int# #)+fetchXorIntArray# = let x = x in x++data ArrayArray#++data MutableArrayArray# s++-- |Create a new mutable array of arrays with the specified number of elements,+-- in the specified state thread, with each element recursively referring to the+-- newly created array.++newArrayArray# :: Int# -> State# s -> (# State# s,MutableArrayArray# s #)+newArrayArray# = let x = x in x++sameMutableArrayArray# :: MutableArrayArray# s -> MutableArrayArray# s -> Int#+sameMutableArrayArray# = let x = x in x++-- |Make a mutable array of arrays immutable, without copying.++unsafeFreezeArrayArray# :: MutableArrayArray# s -> State# s -> (# State# s,ArrayArray# #)+unsafeFreezeArrayArray# = let x = x in x++-- |Return the number of elements in the array.++sizeofArrayArray# :: ArrayArray# -> Int#+sizeofArrayArray# = let x = x in x++-- |Return the number of elements in the array.++sizeofMutableArrayArray# :: MutableArrayArray# s -> Int#+sizeofMutableArrayArray# = let x = x in x++indexByteArrayArray# :: ArrayArray# -> Int# -> ByteArray#+indexByteArrayArray# = let x = x in x++indexArrayArrayArray# :: ArrayArray# -> Int# -> ArrayArray#+indexArrayArrayArray# = let x = x in x++readByteArrayArray# :: MutableArrayArray# s -> Int# -> State# s -> (# State# s,ByteArray# #)+readByteArrayArray# = let x = x in x++readMutableByteArrayArray# :: MutableArrayArray# s -> Int# -> State# s -> (# State# s,MutableByteArray# s #)+readMutableByteArrayArray# = let x = x in x++readArrayArrayArray# :: MutableArrayArray# s -> Int# -> State# s -> (# State# s,ArrayArray# #)+readArrayArrayArray# = let x = x in x++readMutableArrayArrayArray# :: MutableArrayArray# s -> Int# -> State# s -> (# State# s,MutableArrayArray# s #)+readMutableArrayArrayArray# = let x = x in x++writeByteArrayArray# :: MutableArrayArray# s -> Int# -> ByteArray# -> State# s -> State# s+writeByteArrayArray# = let x = x in x++writeMutableByteArrayArray# :: MutableArrayArray# s -> Int# -> MutableByteArray# s -> State# s -> State# s+writeMutableByteArrayArray# = let x = x in x++writeArrayArrayArray# :: MutableArrayArray# s -> Int# -> ArrayArray# -> State# s -> State# s+writeArrayArrayArray# = let x = x in x++writeMutableArrayArrayArray# :: MutableArrayArray# s -> Int# -> MutableArrayArray# s -> State# s -> State# s+writeMutableArrayArrayArray# = let x = x in x++-- |Copy a range of the ArrayArray# to the specified region in the MutableArrayArray#.+-- Both arrays must fully contain the specified ranges, but this is not checked.+-- The two arrays must not be the same array in different states, but this is not checked either.++copyArrayArray# :: ArrayArray# -> Int# -> MutableArrayArray# s -> Int# -> Int# -> State# s -> State# s+copyArrayArray# = let x = x in x++-- |Copy a range of the first MutableArrayArray# to the specified region in the second+-- MutableArrayArray#.+-- Both arrays must fully contain the specified ranges, but this is not checked.++copyMutableArrayArray# :: MutableArrayArray# s -> Int# -> MutableArrayArray# s -> Int# -> Int# -> State# s -> State# s+copyMutableArrayArray# = let x = x in x++-- | An arbitrary machine address assumed to point outside+-- the garbage-collected heap. ++data Addr#++-- | The null address. ++nullAddr# :: Addr#+nullAddr# = let x = x in x++plusAddr# :: Addr# -> Int# -> Addr#+plusAddr# = let x = x in x++-- |Result is meaningless if two @Addr\#@s are so far apart that their+-- difference doesn\'t fit in an @Int\#@.++minusAddr# :: Addr# -> Addr# -> Int#+minusAddr# = let x = x in x++-- |Return the remainder when the @Addr\#@ arg, treated like an @Int\#@,+-- is divided by the @Int\#@ arg.++remAddr# :: Addr# -> Int# -> Int#+remAddr# = let x = x in x++-- |Coerce directly from address to int. Strongly deprecated.++addr2Int# :: Addr# -> Int#+addr2Int# = let x = x in x++-- |Coerce directly from int to address. Strongly deprecated.++int2Addr# :: Int# -> Addr#+int2Addr# = let x = x in x++gtAddr# :: Addr# -> Addr# -> Int#+gtAddr# = let x = x in x++geAddr# :: Addr# -> Addr# -> Int#+geAddr# = let x = x in x++eqAddr# :: Addr# -> Addr# -> Int#+eqAddr# = let x = x in x++neAddr# :: Addr# -> Addr# -> Int#+neAddr# = let x = x in x++ltAddr# :: Addr# -> Addr# -> Int#+ltAddr# = let x = x in x++leAddr# :: Addr# -> Addr# -> Int#+leAddr# = let x = x in x++-- |Reads 8-bit character; offset in bytes.++indexCharOffAddr# :: Addr# -> Int# -> Char#+indexCharOffAddr# = let x = x in x++-- |Reads 31-bit character; offset in 4-byte words.++indexWideCharOffAddr# :: Addr# -> Int# -> Char#+indexWideCharOffAddr# = let x = x in x++indexIntOffAddr# :: Addr# -> Int# -> Int#+indexIntOffAddr# = let x = x in x++indexWordOffAddr# :: Addr# -> Int# -> Word#+indexWordOffAddr# = let x = x in x++indexAddrOffAddr# :: Addr# -> Int# -> Addr#+indexAddrOffAddr# = let x = x in x++indexFloatOffAddr# :: Addr# -> Int# -> Float#+indexFloatOffAddr# = let x = x in x++indexDoubleOffAddr# :: Addr# -> Int# -> Double#+indexDoubleOffAddr# = let x = x in x++indexStablePtrOffAddr# :: Addr# -> Int# -> StablePtr# a+indexStablePtrOffAddr# = let x = x in x++indexInt8OffAddr# :: Addr# -> Int# -> Int#+indexInt8OffAddr# = let x = x in x++indexInt16OffAddr# :: Addr# -> Int# -> Int#+indexInt16OffAddr# = let x = x in x++indexInt32OffAddr# :: Addr# -> Int# -> Int#+indexInt32OffAddr# = let x = x in x++indexInt64OffAddr# :: Addr# -> Int# -> Int#+indexInt64OffAddr# = let x = x in x++indexWord8OffAddr# :: Addr# -> Int# -> Word#+indexWord8OffAddr# = let x = x in x++indexWord16OffAddr# :: Addr# -> Int# -> Word#+indexWord16OffAddr# = let x = x in x++indexWord32OffAddr# :: Addr# -> Int# -> Word#+indexWord32OffAddr# = let x = x in x++indexWord64OffAddr# :: Addr# -> Int# -> Word#+indexWord64OffAddr# = let x = x in x++-- |Reads 8-bit character; offset in bytes.++readCharOffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Char# #)+readCharOffAddr# = let x = x in x++-- |Reads 31-bit character; offset in 4-byte words.++readWideCharOffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Char# #)+readWideCharOffAddr# = let x = x in x++readIntOffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int# #)+readIntOffAddr# = let x = x in x++readWordOffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word# #)+readWordOffAddr# = let x = x in x++readAddrOffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Addr# #)+readAddrOffAddr# = let x = x in x++readFloatOffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Float# #)+readFloatOffAddr# = let x = x in x++readDoubleOffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Double# #)+readDoubleOffAddr# = let x = x in x++readStablePtrOffAddr# :: Addr# -> Int# -> State# s -> (# State# s,StablePtr# a #)+readStablePtrOffAddr# = let x = x in x++readInt8OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int# #)+readInt8OffAddr# = let x = x in x++readInt16OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int# #)+readInt16OffAddr# = let x = x in x++readInt32OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int# #)+readInt32OffAddr# = let x = x in x++readInt64OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int# #)+readInt64OffAddr# = let x = x in x++readWord8OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word# #)+readWord8OffAddr# = let x = x in x++readWord16OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word# #)+readWord16OffAddr# = let x = x in x++readWord32OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word# #)+readWord32OffAddr# = let x = x in x++readWord64OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word# #)+readWord64OffAddr# = let x = x in x++writeCharOffAddr# :: Addr# -> Int# -> Char# -> State# s -> State# s+writeCharOffAddr# = let x = x in x++writeWideCharOffAddr# :: Addr# -> Int# -> Char# -> State# s -> State# s+writeWideCharOffAddr# = let x = x in x++writeIntOffAddr# :: Addr# -> Int# -> Int# -> State# s -> State# s+writeIntOffAddr# = let x = x in x++writeWordOffAddr# :: Addr# -> Int# -> Word# -> State# s -> State# s+writeWordOffAddr# = let x = x in x++writeAddrOffAddr# :: Addr# -> Int# -> Addr# -> State# s -> State# s+writeAddrOffAddr# = let x = x in x++writeFloatOffAddr# :: Addr# -> Int# -> Float# -> State# s -> State# s+writeFloatOffAddr# = let x = x in x++writeDoubleOffAddr# :: Addr# -> Int# -> Double# -> State# s -> State# s+writeDoubleOffAddr# = let x = x in x++writeStablePtrOffAddr# :: Addr# -> Int# -> StablePtr# a -> State# s -> State# s+writeStablePtrOffAddr# = let x = x in x++writeInt8OffAddr# :: Addr# -> Int# -> Int# -> State# s -> State# s+writeInt8OffAddr# = let x = x in x++writeInt16OffAddr# :: Addr# -> Int# -> Int# -> State# s -> State# s+writeInt16OffAddr# = let x = x in x++writeInt32OffAddr# :: Addr# -> Int# -> Int# -> State# s -> State# s+writeInt32OffAddr# = let x = x in x++writeInt64OffAddr# :: Addr# -> Int# -> Int# -> State# s -> State# s+writeInt64OffAddr# = let x = x in x++writeWord8OffAddr# :: Addr# -> Int# -> Word# -> State# s -> State# s+writeWord8OffAddr# = let x = x in x++writeWord16OffAddr# :: Addr# -> Int# -> Word# -> State# s -> State# s+writeWord16OffAddr# = let x = x in x++writeWord32OffAddr# :: Addr# -> Int# -> Word# -> State# s -> State# s+writeWord32OffAddr# = let x = x in x++writeWord64OffAddr# :: Addr# -> Int# -> Word# -> State# s -> State# s+writeWord64OffAddr# = let x = x in x++-- |A @MutVar\#@ behaves like a single-element mutable array.++data MutVar# s a++-- |Create @MutVar\#@ with specified initial value in specified state thread.++newMutVar# :: a -> State# s -> (# State# s,MutVar# s a #)+newMutVar# = let x = x in x++-- |Read contents of @MutVar\#@. Result is not yet evaluated.++readMutVar# :: MutVar# s a -> State# s -> (# State# s,a #)+readMutVar# = let x = x in x++-- |Write contents of @MutVar\#@.++writeMutVar# :: MutVar# s a -> a -> State# s -> State# s+writeMutVar# = let x = x in x++sameMutVar# :: MutVar# s a -> MutVar# s a -> Int#+sameMutVar# = let x = x in x++atomicModifyMutVar# :: MutVar# s a -> (a -> b) -> State# s -> (# State# s,c #)+atomicModifyMutVar# = let x = x in x++casMutVar# :: MutVar# s a -> a -> a -> State# s -> (# State# s,Int#,a #)+casMutVar# = let x = x in x++catch# :: (State# (RealWorld) -> (# State# (RealWorld),a #)) -> (b -> State# (RealWorld) -> (# State# (RealWorld),a #)) -> State# (RealWorld) -> (# State# (RealWorld),a #)+catch# = let x = x in x++raise# :: a -> b+raise# = let x = x in x++raiseIO# :: a -> State# (RealWorld) -> (# State# (RealWorld),b #)+raiseIO# = let x = x in x++maskAsyncExceptions# :: (State# (RealWorld) -> (# State# (RealWorld),a #)) -> State# (RealWorld) -> (# State# (RealWorld),a #)+maskAsyncExceptions# = let x = x in x++maskUninterruptible# :: (State# (RealWorld) -> (# State# (RealWorld),a #)) -> State# (RealWorld) -> (# State# (RealWorld),a #)+maskUninterruptible# = let x = x in x++unmaskAsyncExceptions# :: (State# (RealWorld) -> (# State# (RealWorld),a #)) -> State# (RealWorld) -> (# State# (RealWorld),a #)+unmaskAsyncExceptions# = let x = x in x++getMaskingState# :: State# (RealWorld) -> (# State# (RealWorld),Int# #)+getMaskingState# = let x = x in x++data TVar# s a++atomically# :: (State# (RealWorld) -> (# State# (RealWorld),a #)) -> State# (RealWorld) -> (# State# (RealWorld),a #)+atomically# = let x = x in x++retry# :: State# (RealWorld) -> (# State# (RealWorld),a #)+retry# = let x = x in x++catchRetry# :: (State# (RealWorld) -> (# State# (RealWorld),a #)) -> (State# (RealWorld) -> (# State# (RealWorld),a #)) -> State# (RealWorld) -> (# State# (RealWorld),a #)+catchRetry# = let x = x in x++catchSTM# :: (State# (RealWorld) -> (# State# (RealWorld),a #)) -> (b -> State# (RealWorld) -> (# State# (RealWorld),a #)) -> State# (RealWorld) -> (# State# (RealWorld),a #)+catchSTM# = let x = x in x++check# :: (State# (RealWorld) -> (# State# (RealWorld),a #)) -> State# (RealWorld) -> (# State# (RealWorld),() #)+check# = let x = x in x++-- |Create a new @TVar\#@ holding a specified initial value.++newTVar# :: a -> State# s -> (# State# s,TVar# s a #)+newTVar# = let x = x in x++-- |Read contents of @TVar\#@. Result is not yet evaluated.++readTVar# :: TVar# s a -> State# s -> (# State# s,a #)+readTVar# = let x = x in x++-- |Read contents of @TVar\#@ outside an STM transaction++readTVarIO# :: TVar# s a -> State# s -> (# State# s,a #)+readTVarIO# = let x = x in x++-- |Write contents of @TVar\#@.++writeTVar# :: TVar# s a -> a -> State# s -> State# s+writeTVar# = let x = x in x++sameTVar# :: TVar# s a -> TVar# s a -> Int#+sameTVar# = let x = x in x++-- | A shared mutable variable (/not/ the same as a @MutVar\#@!).+-- (Note: in a non-concurrent implementation, @(MVar\# a)@ can be+-- represented by @(MutVar\# (Maybe a))@.) ++data MVar# s a++-- |Create new @MVar\#@; initially empty.++newMVar# :: State# s -> (# State# s,MVar# s a #)+newMVar# = let x = x in x++-- |If @MVar\#@ is empty, block until it becomes full.+-- Then remove and return its contents, and set it empty.++takeMVar# :: MVar# s a -> State# s -> (# State# s,a #)+takeMVar# = let x = x in x++-- |If @MVar\#@ is empty, immediately return with integer 0 and value undefined.+-- Otherwise, return with integer 1 and contents of @MVar\#@, and set @MVar\#@ empty.++tryTakeMVar# :: MVar# s a -> State# s -> (# State# s,Int#,a #)+tryTakeMVar# = let x = x in x++-- |If @MVar\#@ is full, block until it becomes empty.+-- Then store value arg as its new contents.++putMVar# :: MVar# s a -> a -> State# s -> State# s+putMVar# = let x = x in x++-- |If @MVar\#@ is full, immediately return with integer 0.+-- Otherwise, store value arg as @MVar\#@\'s new contents, and return with integer 1.++tryPutMVar# :: MVar# s a -> a -> State# s -> (# State# s,Int# #)+tryPutMVar# = let x = x in x++-- |If @MVar\#@ is empty, block until it becomes full.+-- Then read its contents without modifying the MVar, without possibility+-- of intervention from other threads.++readMVar# :: MVar# s a -> State# s -> (# State# s,a #)+readMVar# = let x = x in x++-- |If @MVar\#@ is empty, immediately return with integer 0 and value undefined.+-- Otherwise, return with integer 1 and contents of @MVar\#@.++tryReadMVar# :: MVar# s a -> State# s -> (# State# s,Int#,a #)+tryReadMVar# = let x = x in x++sameMVar# :: MVar# s a -> MVar# s a -> Int#+sameMVar# = let x = x in x++-- |Return 1 if @MVar\#@ is empty; 0 otherwise.++isEmptyMVar# :: MVar# s a -> State# s -> (# State# s,Int# #)+isEmptyMVar# = let x = x in x++-- |Sleep specified number of microseconds.++delay# :: Int# -> State# s -> State# s+delay# = let x = x in x++-- |Block until input is available on specified file descriptor.++waitRead# :: Int# -> State# s -> State# s+waitRead# = let x = x in x++-- |Block until output is possible on specified file descriptor.++waitWrite# :: Int# -> State# s -> State# s+waitWrite# = let x = x in x++-- | @State\#@ is the primitive, unlifted type of states. It has+-- one type parameter, thus @State\# RealWorld@, or @State\# s@,+-- where s is a type variable. The only purpose of the type parameter+-- is to keep different state threads separate. It is represented by+-- nothing at all. ++data State# s++-- | @RealWorld@ is deeply magical. It is /primitive/, but it is not+-- /unlifted/ (hence @ptrArg@). We never manipulate values of type+-- @RealWorld@; it\'s only used in the type system, to parameterise @State\#@. ++data RealWorld++-- |(In a non-concurrent implementation, this can be a singleton+-- type, whose (unique) value is returned by @myThreadId\#@. The+-- other operations can be omitted.)++data ThreadId#++fork# :: a -> State# (RealWorld) -> (# State# (RealWorld),ThreadId# #)+fork# = let x = x in x++forkOn# :: Int# -> a -> State# (RealWorld) -> (# State# (RealWorld),ThreadId# #)+forkOn# = let x = x in x++killThread# :: ThreadId# -> a -> State# (RealWorld) -> State# (RealWorld)+killThread# = let x = x in x++yield# :: State# (RealWorld) -> State# (RealWorld)+yield# = let x = x in x++myThreadId# :: State# (RealWorld) -> (# State# (RealWorld),ThreadId# #)+myThreadId# = let x = x in x++labelThread# :: ThreadId# -> Addr# -> State# (RealWorld) -> State# (RealWorld)+labelThread# = let x = x in x++isCurrentThreadBound# :: State# (RealWorld) -> (# State# (RealWorld),Int# #)+isCurrentThreadBound# = let x = x in x++noDuplicate# :: State# (RealWorld) -> State# (RealWorld)+noDuplicate# = let x = x in x++threadStatus# :: ThreadId# -> State# (RealWorld) -> (# State# (RealWorld),Int#,Int#,Int# #)+threadStatus# = let x = x in x++data Weak# b++mkWeak# :: o -> b -> c -> State# (RealWorld) -> (# State# (RealWorld),Weak# b #)+mkWeak# = let x = x in x++mkWeakNoFinalizer# :: o -> b -> State# (RealWorld) -> (# State# (RealWorld),Weak# b #)+mkWeakNoFinalizer# = let x = x in x++-- | @addCFinalizerToWeak# fptr ptr flag eptr w@ attaches a C+-- function pointer @fptr@ to a weak pointer @w@ as a finalizer. If+-- @flag@ is zero, @fptr@ will be called with one argument,+-- @ptr@. Otherwise, it will be called with two arguments,+-- @eptr@ and @ptr@. @addCFinalizerToWeak#@ returns+-- 1 on success, or 0 if @w@ is already dead. ++addCFinalizerToWeak# :: Addr# -> Addr# -> Int# -> Addr# -> Weak# b -> State# (RealWorld) -> (# State# (RealWorld),Int# #)+addCFinalizerToWeak# = let x = x in x++deRefWeak# :: Weak# a -> State# (RealWorld) -> (# State# (RealWorld),Int#,a #)+deRefWeak# = let x = x in x++finalizeWeak# :: Weak# a -> State# (RealWorld) -> (# State# (RealWorld),Int#,State# (RealWorld) -> (# State# (RealWorld),() #) #)+finalizeWeak# = let x = x in x++touch# :: o -> State# (RealWorld) -> State# (RealWorld)+touch# = let x = x in x++data StablePtr# a++data StableName# a++makeStablePtr# :: a -> State# (RealWorld) -> (# State# (RealWorld),StablePtr# a #)+makeStablePtr# = let x = x in x++deRefStablePtr# :: StablePtr# a -> State# (RealWorld) -> (# State# (RealWorld),a #)+deRefStablePtr# = let x = x in x++eqStablePtr# :: StablePtr# a -> StablePtr# a -> Int#+eqStablePtr# = let x = x in x++makeStableName# :: a -> State# (RealWorld) -> (# State# (RealWorld),StableName# a #)+makeStableName# = let x = x in x++eqStableName# :: StableName# a -> StableName# b -> Int#+eqStableName# = let x = x in x++stableNameToInt# :: StableName# a -> Int#+stableNameToInt# = let x = x in x++reallyUnsafePtrEquality# :: a -> a -> Int#+reallyUnsafePtrEquality# = let x = x in x++par# :: a -> Int#+par# = let x = x in x++spark# :: a -> State# s -> (# State# s,a #)+spark# = let x = x in x++seq# :: a -> State# s -> (# State# s,a #)+seq# = let x = x in x++getSpark# :: State# s -> (# State# s,Int#,a #)+getSpark# = let x = x in x++-- | Returns the number of sparks in the local spark pool. ++numSparks# :: State# s -> (# State# s,Int# #)+numSparks# = let x = x in x++parGlobal# :: a -> Int# -> Int# -> Int# -> Int# -> b -> Int#+parGlobal# = let x = x in x++parLocal# :: a -> Int# -> Int# -> Int# -> Int# -> b -> Int#+parLocal# = let x = x in x++parAt# :: b -> a -> Int# -> Int# -> Int# -> Int# -> c -> Int#+parAt# = let x = x in x++parAtAbs# :: a -> Int# -> Int# -> Int# -> Int# -> Int# -> b -> Int#+parAtAbs# = let x = x in x++parAtRel# :: a -> Int# -> Int# -> Int# -> Int# -> Int# -> b -> Int#+parAtRel# = let x = x in x++parAtForNow# :: b -> a -> Int# -> Int# -> Int# -> Int# -> c -> Int#+parAtForNow# = let x = x in x++dataToTag# :: a -> Int#+dataToTag# = let x = x in x++tagToEnum# :: Int# -> a+tagToEnum# = let x = x in x++-- |Primitive bytecode type.++data BCO#++-- |Convert an @Addr\#@ to a followable Any type.++addrToAny# :: Addr# -> (# a #)+addrToAny# = let x = x in x++mkApUpd0# :: BCO# -> (# a #)+mkApUpd0# = let x = x in x++newBCO# :: ByteArray# -> ByteArray# -> Array# a -> Int# -> ByteArray# -> State# s -> (# State# s,BCO# #)+newBCO# = let x = x in x++unpackClosure# :: a -> (# Addr#,Array# b,ByteArray# #)+unpackClosure# = let x = x in x++getApStackVal# :: a -> Int# -> (# Int#,b #)+getApStackVal# = let x = x in x++getCCSOf# :: a -> State# s -> (# State# s,Addr# #)+getCCSOf# = let x = x in x++-- | Returns the current @CostCentreStack@ (value is @NULL@ if+-- not profiling). Takes a dummy argument which can be used to+-- avoid the call to @getCCCS\#@ being floated out by the+-- simplifier, which would result in an uninformative stack+-- (\"CAF\"). ++getCurrentCCS# :: a -> State# s -> (# State# s,Addr# #)+getCurrentCCS# = let x = x in x++-- | The type constructor @Proxy#@ is used to bear witness to some+-- type variable. It\'s used when you want to pass around proxy values+-- for doing things like modelling type applications. A @Proxy#@+-- is not only unboxed, it also has a polymorphic kind, and has no+-- runtime representation, being totally free. ++data Proxy# a++-- | Witness for an unboxed @Proxy#@ value, which has no runtime+-- representation. ++proxy# :: Proxy# a+proxy# = let x = x in x++-- | The value of @seq a b@ is bottom if @a@ is bottom, and+-- otherwise equal to @b@. @seq@ is usually introduced to+-- improve performance by avoiding unneeded laziness.+-- +-- A note on evaluation order: the expression @seq a b@ does+-- /not/ guarantee that @a@ will be evaluated before @b@.+-- The only guarantee given by @seq@ is that the both @a@+-- and @b@ will be evaluated before @seq@ returns a value.+-- In particular, this means that @b@ may be evaluated before+-- @a@. If you need to guarantee a specific order of evaluation,+-- you must use the function @pseq@ from the \"parallel\" package. ++seq :: a -> b -> b+seq = let x = x in x++-- | The type constructor @Any@ is type to which you can unsafely coerce any+-- lifted type, and back.+-- +-- * It is lifted, and hence represented by a pointer+-- +-- * It does not claim to be a /data/ type, and that\'s important for+-- the code generator, because the code gen may /enter/ a data value+-- but never enters a function value.+-- +-- It\'s also used to instantiate un-constrained type variables after type+-- checking. For example, @length@ has type+-- +-- @length :: forall a. [a] -> Int@+-- +-- and the list datacon for the empty list has type+-- +-- @[] :: forall a. [a]@+-- +-- In order to compose these two terms as @length []@ a type+-- application is required, but there is no constraint on the+-- choice. In this situation GHC uses @Any@:+-- +-- @length (Any *) ([] (Any *))@+-- +-- Above, we print kinds explicitly, as if with+-- @-fprint-explicit-kinds@.+-- +-- Note that @Any@ is kind polymorphic; its kind is thus+-- @forall k. k@.++data Any++-- | The kind @AnyK@ is the kind level counterpart to @Any@. In a+-- kind polymorphic setting, a similar example to the length of the empty+-- list can be given at the type level:+-- +-- @type family Length (l :: [k]) :: Nat@+-- @type instance Length [] = Zero@+-- +-- When @Length@ is applied to the empty (promoted) list it will have+-- the kind @Length AnyK []@.+-- +-- @AnyK@ is currently not exported and cannot be used directly, but+-- you might see it in debug output from the compiler.+-- ++data AnyK++-- | The function @unsafeCoerce\#@ allows you to side-step the typechecker entirely. That+-- is, it allows you to coerce any type into any other type. If you use this function,+-- you had better get it right, otherwise segmentation faults await. It is generally+-- used when you want to write a program that you know is well-typed, but where Haskell\'s+-- type system is not expressive enough to prove that it is well typed.+-- +-- The following uses of @unsafeCoerce\#@ are supposed to work (i.e. not lead to+-- spurious compile-time or run-time crashes):+-- +-- * Casting any lifted type to @Any@+-- +-- * Casting @Any@ back to the real type+-- +-- * Casting an unboxed type to another unboxed type of the same size+-- (but not coercions between floating-point and integral types)+-- +-- * Casting between two types that have the same runtime representation. One case is when+-- the two types differ only in \"phantom\" type parameters, for example+-- @Ptr Int@ to @Ptr Float@, or @[Int]@ to @[Float]@ when the list is+-- known to be empty. Also, a @newtype@ of a type @T@ has the same representation+-- at runtime as @T@.+-- +-- Other uses of @unsafeCoerce\#@ are undefined. In particular, you should not use+-- @unsafeCoerce\#@ to cast a T to an algebraic data type D, unless T is also+-- an algebraic data type. For example, do not cast @Int->Int@ to @Bool@, even if+-- you later cast that @Bool@ back to @Int->Int@ before applying it. The reasons+-- have to do with GHC\'s internal representation details (for the congnoscenti, data values+-- can be entered but function closures cannot). If you want a safe type to cast things+-- to, use @Any@, which is not an algebraic data type.+-- +-- ++unsafeCoerce# :: a -> b+unsafeCoerce# = let x = x in x++-- | Emits an event via the RTS tracing framework. The contents+-- of the event is the zero-terminated byte string passed as the first+-- argument. The event will be emitted either to the .eventlog file,+-- or to stderr, depending on the runtime RTS flags. ++traceEvent# :: Addr# -> State# s -> State# s+traceEvent# = let x = x in x++-- | Emits a marker event via the RTS tracing framework. The contents+-- of the event is the zero-terminated byte string passed as the first+-- argument. The event will be emitted either to the .eventlog file,+-- or to stderr, depending on the runtime RTS flags. ++traceMarker# :: Addr# -> State# s -> State# s+traceMarker# = let x = x in x++-- | The function @coerce@ allows you to safely convert between values of+-- types that have the same representation with no run-time overhead. In the+-- simplest case you can use it instead of a newtype constructor, to go from+-- the newtype\'s concrete type to the abstract type. But it also works in+-- more complicated settings, e.g. converting a list of newtypes to a list of+-- concrete types.+-- ++coerce :: Coercible a b => a -> b+coerce = let x = x in x++data Int8X16#++data Int16X8#++data Int32X4#++data Int64X2#++data Int8X32#++data Int16X16#++data Int32X8#++data Int64X4#++data Int8X64#++data Int16X32#++data Int32X16#++data Int64X8#++data Word8X16#++data Word16X8#++data Word32X4#++data Word64X2#++data Word8X32#++data Word16X16#++data Word32X8#++data Word64X4#++data Word8X64#++data Word16X32#++data Word32X16#++data Word64X8#++data FloatX4#++data DoubleX2#++data FloatX8#++data DoubleX4#++data FloatX16#++data DoubleX8#++-- | Broadcast a scalar to all elements of a vector. ++broadcastInt8X16# :: Int# -> Int8X16#+broadcastInt8X16# = let x = x in x++-- | Broadcast a scalar to all elements of a vector. ++broadcastInt16X8# :: Int# -> Int16X8#+broadcastInt16X8# = let x = x in x++-- | Broadcast a scalar to all elements of a vector. ++broadcastInt32X4# :: Int# -> Int32X4#+broadcastInt32X4# = let x = x in x++-- | Broadcast a scalar to all elements of a vector. ++broadcastInt64X2# :: Int# -> Int64X2#+broadcastInt64X2# = let x = x in x++-- | Broadcast a scalar to all elements of a vector. ++broadcastInt8X32# :: Int# -> Int8X32#+broadcastInt8X32# = let x = x in x++-- | Broadcast a scalar to all elements of a vector. ++broadcastInt16X16# :: Int# -> Int16X16#+broadcastInt16X16# = let x = x in x++-- | Broadcast a scalar to all elements of a vector. ++broadcastInt32X8# :: Int# -> Int32X8#+broadcastInt32X8# = let x = x in x++-- | Broadcast a scalar to all elements of a vector. ++broadcastInt64X4# :: Int# -> Int64X4#+broadcastInt64X4# = let x = x in x++-- | Broadcast a scalar to all elements of a vector. ++broadcastInt8X64# :: Int# -> Int8X64#+broadcastInt8X64# = let x = x in x++-- | Broadcast a scalar to all elements of a vector. ++broadcastInt16X32# :: Int# -> Int16X32#+broadcastInt16X32# = let x = x in x++-- | Broadcast a scalar to all elements of a vector. ++broadcastInt32X16# :: Int# -> Int32X16#+broadcastInt32X16# = let x = x in x++-- | Broadcast a scalar to all elements of a vector. ++broadcastInt64X8# :: Int# -> Int64X8#+broadcastInt64X8# = let x = x in x++-- | Broadcast a scalar to all elements of a vector. ++broadcastWord8X16# :: Word# -> Word8X16#+broadcastWord8X16# = let x = x in x++-- | Broadcast a scalar to all elements of a vector. ++broadcastWord16X8# :: Word# -> Word16X8#+broadcastWord16X8# = let x = x in x++-- | Broadcast a scalar to all elements of a vector. ++broadcastWord32X4# :: Word# -> Word32X4#+broadcastWord32X4# = let x = x in x++-- | Broadcast a scalar to all elements of a vector. ++broadcastWord64X2# :: Word# -> Word64X2#+broadcastWord64X2# = let x = x in x++-- | Broadcast a scalar to all elements of a vector. ++broadcastWord8X32# :: Word# -> Word8X32#+broadcastWord8X32# = let x = x in x++-- | Broadcast a scalar to all elements of a vector. ++broadcastWord16X16# :: Word# -> Word16X16#+broadcastWord16X16# = let x = x in x++-- | Broadcast a scalar to all elements of a vector. ++broadcastWord32X8# :: Word# -> Word32X8#+broadcastWord32X8# = let x = x in x++-- | Broadcast a scalar to all elements of a vector. ++broadcastWord64X4# :: Word# -> Word64X4#+broadcastWord64X4# = let x = x in x++-- | Broadcast a scalar to all elements of a vector. ++broadcastWord8X64# :: Word# -> Word8X64#+broadcastWord8X64# = let x = x in x++-- | Broadcast a scalar to all elements of a vector. ++broadcastWord16X32# :: Word# -> Word16X32#+broadcastWord16X32# = let x = x in x++-- | Broadcast a scalar to all elements of a vector. ++broadcastWord32X16# :: Word# -> Word32X16#+broadcastWord32X16# = let x = x in x++-- | Broadcast a scalar to all elements of a vector. ++broadcastWord64X8# :: Word# -> Word64X8#+broadcastWord64X8# = let x = x in x++-- | Broadcast a scalar to all elements of a vector. ++broadcastFloatX4# :: Float# -> FloatX4#+broadcastFloatX4# = let x = x in x++-- | Broadcast a scalar to all elements of a vector. ++broadcastDoubleX2# :: Double# -> DoubleX2#+broadcastDoubleX2# = let x = x in x++-- | Broadcast a scalar to all elements of a vector. ++broadcastFloatX8# :: Float# -> FloatX8#+broadcastFloatX8# = let x = x in x++-- | Broadcast a scalar to all elements of a vector. ++broadcastDoubleX4# :: Double# -> DoubleX4#+broadcastDoubleX4# = let x = x in x++-- | Broadcast a scalar to all elements of a vector. ++broadcastFloatX16# :: Float# -> FloatX16#+broadcastFloatX16# = let x = x in x++-- | Broadcast a scalar to all elements of a vector. ++broadcastDoubleX8# :: Double# -> DoubleX8#+broadcastDoubleX8# = let x = x in x++-- | Pack the elements of an unboxed tuple into a vector. ++packInt8X16# :: (# Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int# #) -> Int8X16#+packInt8X16# = let x = x in x++-- | Pack the elements of an unboxed tuple into a vector. ++packInt16X8# :: (# Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int# #) -> Int16X8#+packInt16X8# = let x = x in x++-- | Pack the elements of an unboxed tuple into a vector. ++packInt32X4# :: (# Int#,Int#,Int#,Int# #) -> Int32X4#+packInt32X4# = let x = x in x++-- | Pack the elements of an unboxed tuple into a vector. ++packInt64X2# :: (# Int#,Int# #) -> Int64X2#+packInt64X2# = let x = x in x++-- | Pack the elements of an unboxed tuple into a vector. ++packInt8X32# :: (# Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int# #) -> Int8X32#+packInt8X32# = let x = x in x++-- | Pack the elements of an unboxed tuple into a vector. ++packInt16X16# :: (# Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int# #) -> Int16X16#+packInt16X16# = let x = x in x++-- | Pack the elements of an unboxed tuple into a vector. ++packInt32X8# :: (# Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int# #) -> Int32X8#+packInt32X8# = let x = x in x++-- | Pack the elements of an unboxed tuple into a vector. ++packInt64X4# :: (# Int#,Int#,Int#,Int# #) -> Int64X4#+packInt64X4# = let x = x in x++-- | Pack the elements of an unboxed tuple into a vector. ++packInt8X64# :: (# Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int# #) -> Int8X64#+packInt8X64# = let x = x in x++-- | Pack the elements of an unboxed tuple into a vector. ++packInt16X32# :: (# Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int# #) -> Int16X32#+packInt16X32# = let x = x in x++-- | Pack the elements of an unboxed tuple into a vector. ++packInt32X16# :: (# Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int# #) -> Int32X16#+packInt32X16# = let x = x in x++-- | Pack the elements of an unboxed tuple into a vector. ++packInt64X8# :: (# Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int# #) -> Int64X8#+packInt64X8# = let x = x in x++-- | Pack the elements of an unboxed tuple into a vector. ++packWord8X16# :: (# Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word# #) -> Word8X16#+packWord8X16# = let x = x in x++-- | Pack the elements of an unboxed tuple into a vector. ++packWord16X8# :: (# Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word# #) -> Word16X8#+packWord16X8# = let x = x in x++-- | Pack the elements of an unboxed tuple into a vector. ++packWord32X4# :: (# Word#,Word#,Word#,Word# #) -> Word32X4#+packWord32X4# = let x = x in x++-- | Pack the elements of an unboxed tuple into a vector. ++packWord64X2# :: (# Word#,Word# #) -> Word64X2#+packWord64X2# = let x = x in x++-- | Pack the elements of an unboxed tuple into a vector. ++packWord8X32# :: (# Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word# #) -> Word8X32#+packWord8X32# = let x = x in x++-- | Pack the elements of an unboxed tuple into a vector. ++packWord16X16# :: (# Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word# #) -> Word16X16#+packWord16X16# = let x = x in x++-- | Pack the elements of an unboxed tuple into a vector. ++packWord32X8# :: (# Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word# #) -> Word32X8#+packWord32X8# = let x = x in x++-- | Pack the elements of an unboxed tuple into a vector. ++packWord64X4# :: (# Word#,Word#,Word#,Word# #) -> Word64X4#+packWord64X4# = let x = x in x++-- | Pack the elements of an unboxed tuple into a vector. ++packWord8X64# :: (# Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word# #) -> Word8X64#+packWord8X64# = let x = x in x++-- | Pack the elements of an unboxed tuple into a vector. ++packWord16X32# :: (# Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word# #) -> Word16X32#+packWord16X32# = let x = x in x++-- | Pack the elements of an unboxed tuple into a vector. ++packWord32X16# :: (# Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word# #) -> Word32X16#+packWord32X16# = let x = x in x++-- | Pack the elements of an unboxed tuple into a vector. ++packWord64X8# :: (# Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word# #) -> Word64X8#+packWord64X8# = let x = x in x++-- | Pack the elements of an unboxed tuple into a vector. ++packFloatX4# :: (# Float#,Float#,Float#,Float# #) -> FloatX4#+packFloatX4# = let x = x in x++-- | Pack the elements of an unboxed tuple into a vector. ++packDoubleX2# :: (# Double#,Double# #) -> DoubleX2#+packDoubleX2# = let x = x in x++-- | Pack the elements of an unboxed tuple into a vector. ++packFloatX8# :: (# Float#,Float#,Float#,Float#,Float#,Float#,Float#,Float# #) -> FloatX8#+packFloatX8# = let x = x in x++-- | Pack the elements of an unboxed tuple into a vector. ++packDoubleX4# :: (# Double#,Double#,Double#,Double# #) -> DoubleX4#+packDoubleX4# = let x = x in x++-- | Pack the elements of an unboxed tuple into a vector. ++packFloatX16# :: (# Float#,Float#,Float#,Float#,Float#,Float#,Float#,Float#,Float#,Float#,Float#,Float#,Float#,Float#,Float#,Float# #) -> FloatX16#+packFloatX16# = let x = x in x++-- | Pack the elements of an unboxed tuple into a vector. ++packDoubleX8# :: (# Double#,Double#,Double#,Double#,Double#,Double#,Double#,Double# #) -> DoubleX8#+packDoubleX8# = let x = x in x++-- | Unpack the elements of a vector into an unboxed tuple. #++unpackInt8X16# :: Int8X16# -> (# Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int# #)+unpackInt8X16# = let x = x in x++-- | Unpack the elements of a vector into an unboxed tuple. #++unpackInt16X8# :: Int16X8# -> (# Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int# #)+unpackInt16X8# = let x = x in x++-- | Unpack the elements of a vector into an unboxed tuple. #++unpackInt32X4# :: Int32X4# -> (# Int#,Int#,Int#,Int# #)+unpackInt32X4# = let x = x in x++-- | Unpack the elements of a vector into an unboxed tuple. #++unpackInt64X2# :: Int64X2# -> (# Int#,Int# #)+unpackInt64X2# = let x = x in x++-- | Unpack the elements of a vector into an unboxed tuple. #++unpackInt8X32# :: Int8X32# -> (# Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int# #)+unpackInt8X32# = let x = x in x++-- | Unpack the elements of a vector into an unboxed tuple. #++unpackInt16X16# :: Int16X16# -> (# Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int# #)+unpackInt16X16# = let x = x in x++-- | Unpack the elements of a vector into an unboxed tuple. #++unpackInt32X8# :: Int32X8# -> (# Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int# #)+unpackInt32X8# = let x = x in x++-- | Unpack the elements of a vector into an unboxed tuple. #++unpackInt64X4# :: Int64X4# -> (# Int#,Int#,Int#,Int# #)+unpackInt64X4# = let x = x in x++-- | Unpack the elements of a vector into an unboxed tuple. #++unpackInt8X64# :: Int8X64# -> (# Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int# #)+unpackInt8X64# = let x = x in x++-- | Unpack the elements of a vector into an unboxed tuple. #++unpackInt16X32# :: Int16X32# -> (# Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int# #)+unpackInt16X32# = let x = x in x++-- | Unpack the elements of a vector into an unboxed tuple. #++unpackInt32X16# :: Int32X16# -> (# Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int# #)+unpackInt32X16# = let x = x in x++-- | Unpack the elements of a vector into an unboxed tuple. #++unpackInt64X8# :: Int64X8# -> (# Int#,Int#,Int#,Int#,Int#,Int#,Int#,Int# #)+unpackInt64X8# = let x = x in x++-- | Unpack the elements of a vector into an unboxed tuple. #++unpackWord8X16# :: Word8X16# -> (# Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word# #)+unpackWord8X16# = let x = x in x++-- | Unpack the elements of a vector into an unboxed tuple. #++unpackWord16X8# :: Word16X8# -> (# Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word# #)+unpackWord16X8# = let x = x in x++-- | Unpack the elements of a vector into an unboxed tuple. #++unpackWord32X4# :: Word32X4# -> (# Word#,Word#,Word#,Word# #)+unpackWord32X4# = let x = x in x++-- | Unpack the elements of a vector into an unboxed tuple. #++unpackWord64X2# :: Word64X2# -> (# Word#,Word# #)+unpackWord64X2# = let x = x in x++-- | Unpack the elements of a vector into an unboxed tuple. #++unpackWord8X32# :: Word8X32# -> (# Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word# #)+unpackWord8X32# = let x = x in x++-- | Unpack the elements of a vector into an unboxed tuple. #++unpackWord16X16# :: Word16X16# -> (# Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word# #)+unpackWord16X16# = let x = x in x++-- | Unpack the elements of a vector into an unboxed tuple. #++unpackWord32X8# :: Word32X8# -> (# Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word# #)+unpackWord32X8# = let x = x in x++-- | Unpack the elements of a vector into an unboxed tuple. #++unpackWord64X4# :: Word64X4# -> (# Word#,Word#,Word#,Word# #)+unpackWord64X4# = let x = x in x++-- | Unpack the elements of a vector into an unboxed tuple. #++unpackWord8X64# :: Word8X64# -> (# Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word# #)+unpackWord8X64# = let x = x in x++-- | Unpack the elements of a vector into an unboxed tuple. #++unpackWord16X32# :: Word16X32# -> (# Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word# #)+unpackWord16X32# = let x = x in x++-- | Unpack the elements of a vector into an unboxed tuple. #++unpackWord32X16# :: Word32X16# -> (# Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word# #)+unpackWord32X16# = let x = x in x++-- | Unpack the elements of a vector into an unboxed tuple. #++unpackWord64X8# :: Word64X8# -> (# Word#,Word#,Word#,Word#,Word#,Word#,Word#,Word# #)+unpackWord64X8# = let x = x in x++-- | Unpack the elements of a vector into an unboxed tuple. #++unpackFloatX4# :: FloatX4# -> (# Float#,Float#,Float#,Float# #)+unpackFloatX4# = let x = x in x++-- | Unpack the elements of a vector into an unboxed tuple. #++unpackDoubleX2# :: DoubleX2# -> (# Double#,Double# #)+unpackDoubleX2# = let x = x in x++-- | Unpack the elements of a vector into an unboxed tuple. #++unpackFloatX8# :: FloatX8# -> (# Float#,Float#,Float#,Float#,Float#,Float#,Float#,Float# #)+unpackFloatX8# = let x = x in x++-- | Unpack the elements of a vector into an unboxed tuple. #++unpackDoubleX4# :: DoubleX4# -> (# Double#,Double#,Double#,Double# #)+unpackDoubleX4# = let x = x in x++-- | Unpack the elements of a vector into an unboxed tuple. #++unpackFloatX16# :: FloatX16# -> (# Float#,Float#,Float#,Float#,Float#,Float#,Float#,Float#,Float#,Float#,Float#,Float#,Float#,Float#,Float#,Float# #)+unpackFloatX16# = let x = x in x++-- | Unpack the elements of a vector into an unboxed tuple. #++unpackDoubleX8# :: DoubleX8# -> (# Double#,Double#,Double#,Double#,Double#,Double#,Double#,Double# #)+unpackDoubleX8# = let x = x in x++-- | Insert a scalar at the given position in a vector. ++insertInt8X16# :: Int8X16# -> Int# -> Int# -> Int8X16#+insertInt8X16# = let x = x in x++-- | Insert a scalar at the given position in a vector. ++insertInt16X8# :: Int16X8# -> Int# -> Int# -> Int16X8#+insertInt16X8# = let x = x in x++-- | Insert a scalar at the given position in a vector. ++insertInt32X4# :: Int32X4# -> Int# -> Int# -> Int32X4#+insertInt32X4# = let x = x in x++-- | Insert a scalar at the given position in a vector. ++insertInt64X2# :: Int64X2# -> Int# -> Int# -> Int64X2#+insertInt64X2# = let x = x in x++-- | Insert a scalar at the given position in a vector. ++insertInt8X32# :: Int8X32# -> Int# -> Int# -> Int8X32#+insertInt8X32# = let x = x in x++-- | Insert a scalar at the given position in a vector. ++insertInt16X16# :: Int16X16# -> Int# -> Int# -> Int16X16#+insertInt16X16# = let x = x in x++-- | Insert a scalar at the given position in a vector. ++insertInt32X8# :: Int32X8# -> Int# -> Int# -> Int32X8#+insertInt32X8# = let x = x in x++-- | Insert a scalar at the given position in a vector. ++insertInt64X4# :: Int64X4# -> Int# -> Int# -> Int64X4#+insertInt64X4# = let x = x in x++-- | Insert a scalar at the given position in a vector. ++insertInt8X64# :: Int8X64# -> Int# -> Int# -> Int8X64#+insertInt8X64# = let x = x in x++-- | Insert a scalar at the given position in a vector. ++insertInt16X32# :: Int16X32# -> Int# -> Int# -> Int16X32#+insertInt16X32# = let x = x in x++-- | Insert a scalar at the given position in a vector. ++insertInt32X16# :: Int32X16# -> Int# -> Int# -> Int32X16#+insertInt32X16# = let x = x in x++-- | Insert a scalar at the given position in a vector. ++insertInt64X8# :: Int64X8# -> Int# -> Int# -> Int64X8#+insertInt64X8# = let x = x in x++-- | Insert a scalar at the given position in a vector. ++insertWord8X16# :: Word8X16# -> Word# -> Int# -> Word8X16#+insertWord8X16# = let x = x in x++-- | Insert a scalar at the given position in a vector. ++insertWord16X8# :: Word16X8# -> Word# -> Int# -> Word16X8#+insertWord16X8# = let x = x in x++-- | Insert a scalar at the given position in a vector. ++insertWord32X4# :: Word32X4# -> Word# -> Int# -> Word32X4#+insertWord32X4# = let x = x in x++-- | Insert a scalar at the given position in a vector. ++insertWord64X2# :: Word64X2# -> Word# -> Int# -> Word64X2#+insertWord64X2# = let x = x in x++-- | Insert a scalar at the given position in a vector. ++insertWord8X32# :: Word8X32# -> Word# -> Int# -> Word8X32#+insertWord8X32# = let x = x in x++-- | Insert a scalar at the given position in a vector. ++insertWord16X16# :: Word16X16# -> Word# -> Int# -> Word16X16#+insertWord16X16# = let x = x in x++-- | Insert a scalar at the given position in a vector. ++insertWord32X8# :: Word32X8# -> Word# -> Int# -> Word32X8#+insertWord32X8# = let x = x in x++-- | Insert a scalar at the given position in a vector. ++insertWord64X4# :: Word64X4# -> Word# -> Int# -> Word64X4#+insertWord64X4# = let x = x in x++-- | Insert a scalar at the given position in a vector. ++insertWord8X64# :: Word8X64# -> Word# -> Int# -> Word8X64#+insertWord8X64# = let x = x in x++-- | Insert a scalar at the given position in a vector. ++insertWord16X32# :: Word16X32# -> Word# -> Int# -> Word16X32#+insertWord16X32# = let x = x in x++-- | Insert a scalar at the given position in a vector. ++insertWord32X16# :: Word32X16# -> Word# -> Int# -> Word32X16#+insertWord32X16# = let x = x in x++-- | Insert a scalar at the given position in a vector. ++insertWord64X8# :: Word64X8# -> Word# -> Int# -> Word64X8#+insertWord64X8# = let x = x in x++-- | Insert a scalar at the given position in a vector. ++insertFloatX4# :: FloatX4# -> Float# -> Int# -> FloatX4#+insertFloatX4# = let x = x in x++-- | Insert a scalar at the given position in a vector. ++insertDoubleX2# :: DoubleX2# -> Double# -> Int# -> DoubleX2#+insertDoubleX2# = let x = x in x++-- | Insert a scalar at the given position in a vector. ++insertFloatX8# :: FloatX8# -> Float# -> Int# -> FloatX8#+insertFloatX8# = let x = x in x++-- | Insert a scalar at the given position in a vector. ++insertDoubleX4# :: DoubleX4# -> Double# -> Int# -> DoubleX4#+insertDoubleX4# = let x = x in x++-- | Insert a scalar at the given position in a vector. ++insertFloatX16# :: FloatX16# -> Float# -> Int# -> FloatX16#+insertFloatX16# = let x = x in x++-- | Insert a scalar at the given position in a vector. ++insertDoubleX8# :: DoubleX8# -> Double# -> Int# -> DoubleX8#+insertDoubleX8# = let x = x in x++-- | Add two vectors element-wise. ++plusInt8X16# :: Int8X16# -> Int8X16# -> Int8X16#+plusInt8X16# = let x = x in x++-- | Add two vectors element-wise. ++plusInt16X8# :: Int16X8# -> Int16X8# -> Int16X8#+plusInt16X8# = let x = x in x++-- | Add two vectors element-wise. ++plusInt32X4# :: Int32X4# -> Int32X4# -> Int32X4#+plusInt32X4# = let x = x in x++-- | Add two vectors element-wise. ++plusInt64X2# :: Int64X2# -> Int64X2# -> Int64X2#+plusInt64X2# = let x = x in x++-- | Add two vectors element-wise. ++plusInt8X32# :: Int8X32# -> Int8X32# -> Int8X32#+plusInt8X32# = let x = x in x++-- | Add two vectors element-wise. ++plusInt16X16# :: Int16X16# -> Int16X16# -> Int16X16#+plusInt16X16# = let x = x in x++-- | Add two vectors element-wise. ++plusInt32X8# :: Int32X8# -> Int32X8# -> Int32X8#+plusInt32X8# = let x = x in x++-- | Add two vectors element-wise. ++plusInt64X4# :: Int64X4# -> Int64X4# -> Int64X4#+plusInt64X4# = let x = x in x++-- | Add two vectors element-wise. ++plusInt8X64# :: Int8X64# -> Int8X64# -> Int8X64#+plusInt8X64# = let x = x in x++-- | Add two vectors element-wise. ++plusInt16X32# :: Int16X32# -> Int16X32# -> Int16X32#+plusInt16X32# = let x = x in x++-- | Add two vectors element-wise. ++plusInt32X16# :: Int32X16# -> Int32X16# -> Int32X16#+plusInt32X16# = let x = x in x++-- | Add two vectors element-wise. ++plusInt64X8# :: Int64X8# -> Int64X8# -> Int64X8#+plusInt64X8# = let x = x in x++-- | Add two vectors element-wise. ++plusWord8X16# :: Word8X16# -> Word8X16# -> Word8X16#+plusWord8X16# = let x = x in x++-- | Add two vectors element-wise. ++plusWord16X8# :: Word16X8# -> Word16X8# -> Word16X8#+plusWord16X8# = let x = x in x++-- | Add two vectors element-wise. ++plusWord32X4# :: Word32X4# -> Word32X4# -> Word32X4#+plusWord32X4# = let x = x in x++-- | Add two vectors element-wise. ++plusWord64X2# :: Word64X2# -> Word64X2# -> Word64X2#+plusWord64X2# = let x = x in x++-- | Add two vectors element-wise. ++plusWord8X32# :: Word8X32# -> Word8X32# -> Word8X32#+plusWord8X32# = let x = x in x++-- | Add two vectors element-wise. ++plusWord16X16# :: Word16X16# -> Word16X16# -> Word16X16#+plusWord16X16# = let x = x in x++-- | Add two vectors element-wise. ++plusWord32X8# :: Word32X8# -> Word32X8# -> Word32X8#+plusWord32X8# = let x = x in x++-- | Add two vectors element-wise. ++plusWord64X4# :: Word64X4# -> Word64X4# -> Word64X4#+plusWord64X4# = let x = x in x++-- | Add two vectors element-wise. ++plusWord8X64# :: Word8X64# -> Word8X64# -> Word8X64#+plusWord8X64# = let x = x in x++-- | Add two vectors element-wise. ++plusWord16X32# :: Word16X32# -> Word16X32# -> Word16X32#+plusWord16X32# = let x = x in x++-- | Add two vectors element-wise. ++plusWord32X16# :: Word32X16# -> Word32X16# -> Word32X16#+plusWord32X16# = let x = x in x++-- | Add two vectors element-wise. ++plusWord64X8# :: Word64X8# -> Word64X8# -> Word64X8#+plusWord64X8# = let x = x in x++-- | Add two vectors element-wise. ++plusFloatX4# :: FloatX4# -> FloatX4# -> FloatX4#+plusFloatX4# = let x = x in x++-- | Add two vectors element-wise. ++plusDoubleX2# :: DoubleX2# -> DoubleX2# -> DoubleX2#+plusDoubleX2# = let x = x in x++-- | Add two vectors element-wise. ++plusFloatX8# :: FloatX8# -> FloatX8# -> FloatX8#+plusFloatX8# = let x = x in x++-- | Add two vectors element-wise. ++plusDoubleX4# :: DoubleX4# -> DoubleX4# -> DoubleX4#+plusDoubleX4# = let x = x in x++-- | Add two vectors element-wise. ++plusFloatX16# :: FloatX16# -> FloatX16# -> FloatX16#+plusFloatX16# = let x = x in x++-- | Add two vectors element-wise. ++plusDoubleX8# :: DoubleX8# -> DoubleX8# -> DoubleX8#+plusDoubleX8# = let x = x in x++-- | Subtract two vectors element-wise. ++minusInt8X16# :: Int8X16# -> Int8X16# -> Int8X16#+minusInt8X16# = let x = x in x++-- | Subtract two vectors element-wise. ++minusInt16X8# :: Int16X8# -> Int16X8# -> Int16X8#+minusInt16X8# = let x = x in x++-- | Subtract two vectors element-wise. ++minusInt32X4# :: Int32X4# -> Int32X4# -> Int32X4#+minusInt32X4# = let x = x in x++-- | Subtract two vectors element-wise. ++minusInt64X2# :: Int64X2# -> Int64X2# -> Int64X2#+minusInt64X2# = let x = x in x++-- | Subtract two vectors element-wise. ++minusInt8X32# :: Int8X32# -> Int8X32# -> Int8X32#+minusInt8X32# = let x = x in x++-- | Subtract two vectors element-wise. ++minusInt16X16# :: Int16X16# -> Int16X16# -> Int16X16#+minusInt16X16# = let x = x in x++-- | Subtract two vectors element-wise. ++minusInt32X8# :: Int32X8# -> Int32X8# -> Int32X8#+minusInt32X8# = let x = x in x++-- | Subtract two vectors element-wise. ++minusInt64X4# :: Int64X4# -> Int64X4# -> Int64X4#+minusInt64X4# = let x = x in x++-- | Subtract two vectors element-wise. ++minusInt8X64# :: Int8X64# -> Int8X64# -> Int8X64#+minusInt8X64# = let x = x in x++-- | Subtract two vectors element-wise. ++minusInt16X32# :: Int16X32# -> Int16X32# -> Int16X32#+minusInt16X32# = let x = x in x++-- | Subtract two vectors element-wise. ++minusInt32X16# :: Int32X16# -> Int32X16# -> Int32X16#+minusInt32X16# = let x = x in x++-- | Subtract two vectors element-wise. ++minusInt64X8# :: Int64X8# -> Int64X8# -> Int64X8#+minusInt64X8# = let x = x in x++-- | Subtract two vectors element-wise. ++minusWord8X16# :: Word8X16# -> Word8X16# -> Word8X16#+minusWord8X16# = let x = x in x++-- | Subtract two vectors element-wise. ++minusWord16X8# :: Word16X8# -> Word16X8# -> Word16X8#+minusWord16X8# = let x = x in x++-- | Subtract two vectors element-wise. ++minusWord32X4# :: Word32X4# -> Word32X4# -> Word32X4#+minusWord32X4# = let x = x in x++-- | Subtract two vectors element-wise. ++minusWord64X2# :: Word64X2# -> Word64X2# -> Word64X2#+minusWord64X2# = let x = x in x++-- | Subtract two vectors element-wise. ++minusWord8X32# :: Word8X32# -> Word8X32# -> Word8X32#+minusWord8X32# = let x = x in x++-- | Subtract two vectors element-wise. ++minusWord16X16# :: Word16X16# -> Word16X16# -> Word16X16#+minusWord16X16# = let x = x in x++-- | Subtract two vectors element-wise. ++minusWord32X8# :: Word32X8# -> Word32X8# -> Word32X8#+minusWord32X8# = let x = x in x++-- | Subtract two vectors element-wise. ++minusWord64X4# :: Word64X4# -> Word64X4# -> Word64X4#+minusWord64X4# = let x = x in x++-- | Subtract two vectors element-wise. ++minusWord8X64# :: Word8X64# -> Word8X64# -> Word8X64#+minusWord8X64# = let x = x in x++-- | Subtract two vectors element-wise. ++minusWord16X32# :: Word16X32# -> Word16X32# -> Word16X32#+minusWord16X32# = let x = x in x++-- | Subtract two vectors element-wise. ++minusWord32X16# :: Word32X16# -> Word32X16# -> Word32X16#+minusWord32X16# = let x = x in x++-- | Subtract two vectors element-wise. ++minusWord64X8# :: Word64X8# -> Word64X8# -> Word64X8#+minusWord64X8# = let x = x in x++-- | Subtract two vectors element-wise. ++minusFloatX4# :: FloatX4# -> FloatX4# -> FloatX4#+minusFloatX4# = let x = x in x++-- | Subtract two vectors element-wise. ++minusDoubleX2# :: DoubleX2# -> DoubleX2# -> DoubleX2#+minusDoubleX2# = let x = x in x++-- | Subtract two vectors element-wise. ++minusFloatX8# :: FloatX8# -> FloatX8# -> FloatX8#+minusFloatX8# = let x = x in x++-- | Subtract two vectors element-wise. ++minusDoubleX4# :: DoubleX4# -> DoubleX4# -> DoubleX4#+minusDoubleX4# = let x = x in x++-- | Subtract two vectors element-wise. ++minusFloatX16# :: FloatX16# -> FloatX16# -> FloatX16#+minusFloatX16# = let x = x in x++-- | Subtract two vectors element-wise. ++minusDoubleX8# :: DoubleX8# -> DoubleX8# -> DoubleX8#+minusDoubleX8# = let x = x in x++-- | Multiply two vectors element-wise. ++timesInt8X16# :: Int8X16# -> Int8X16# -> Int8X16#+timesInt8X16# = let x = x in x++-- | Multiply two vectors element-wise. ++timesInt16X8# :: Int16X8# -> Int16X8# -> Int16X8#+timesInt16X8# = let x = x in x++-- | Multiply two vectors element-wise. ++timesInt32X4# :: Int32X4# -> Int32X4# -> Int32X4#+timesInt32X4# = let x = x in x++-- | Multiply two vectors element-wise. ++timesInt64X2# :: Int64X2# -> Int64X2# -> Int64X2#+timesInt64X2# = let x = x in x++-- | Multiply two vectors element-wise. ++timesInt8X32# :: Int8X32# -> Int8X32# -> Int8X32#+timesInt8X32# = let x = x in x++-- | Multiply two vectors element-wise. ++timesInt16X16# :: Int16X16# -> Int16X16# -> Int16X16#+timesInt16X16# = let x = x in x++-- | Multiply two vectors element-wise. ++timesInt32X8# :: Int32X8# -> Int32X8# -> Int32X8#+timesInt32X8# = let x = x in x++-- | Multiply two vectors element-wise. ++timesInt64X4# :: Int64X4# -> Int64X4# -> Int64X4#+timesInt64X4# = let x = x in x++-- | Multiply two vectors element-wise. ++timesInt8X64# :: Int8X64# -> Int8X64# -> Int8X64#+timesInt8X64# = let x = x in x++-- | Multiply two vectors element-wise. ++timesInt16X32# :: Int16X32# -> Int16X32# -> Int16X32#+timesInt16X32# = let x = x in x++-- | Multiply two vectors element-wise. ++timesInt32X16# :: Int32X16# -> Int32X16# -> Int32X16#+timesInt32X16# = let x = x in x++-- | Multiply two vectors element-wise. ++timesInt64X8# :: Int64X8# -> Int64X8# -> Int64X8#+timesInt64X8# = let x = x in x++-- | Multiply two vectors element-wise. ++timesWord8X16# :: Word8X16# -> Word8X16# -> Word8X16#+timesWord8X16# = let x = x in x++-- | Multiply two vectors element-wise. ++timesWord16X8# :: Word16X8# -> Word16X8# -> Word16X8#+timesWord16X8# = let x = x in x++-- | Multiply two vectors element-wise. ++timesWord32X4# :: Word32X4# -> Word32X4# -> Word32X4#+timesWord32X4# = let x = x in x++-- | Multiply two vectors element-wise. ++timesWord64X2# :: Word64X2# -> Word64X2# -> Word64X2#+timesWord64X2# = let x = x in x++-- | Multiply two vectors element-wise. ++timesWord8X32# :: Word8X32# -> Word8X32# -> Word8X32#+timesWord8X32# = let x = x in x++-- | Multiply two vectors element-wise. ++timesWord16X16# :: Word16X16# -> Word16X16# -> Word16X16#+timesWord16X16# = let x = x in x++-- | Multiply two vectors element-wise. ++timesWord32X8# :: Word32X8# -> Word32X8# -> Word32X8#+timesWord32X8# = let x = x in x++-- | Multiply two vectors element-wise. ++timesWord64X4# :: Word64X4# -> Word64X4# -> Word64X4#+timesWord64X4# = let x = x in x++-- | Multiply two vectors element-wise. ++timesWord8X64# :: Word8X64# -> Word8X64# -> Word8X64#+timesWord8X64# = let x = x in x++-- | Multiply two vectors element-wise. ++timesWord16X32# :: Word16X32# -> Word16X32# -> Word16X32#+timesWord16X32# = let x = x in x++-- | Multiply two vectors element-wise. ++timesWord32X16# :: Word32X16# -> Word32X16# -> Word32X16#+timesWord32X16# = let x = x in x++-- | Multiply two vectors element-wise. ++timesWord64X8# :: Word64X8# -> Word64X8# -> Word64X8#+timesWord64X8# = let x = x in x++-- | Multiply two vectors element-wise. ++timesFloatX4# :: FloatX4# -> FloatX4# -> FloatX4#+timesFloatX4# = let x = x in x++-- | Multiply two vectors element-wise. ++timesDoubleX2# :: DoubleX2# -> DoubleX2# -> DoubleX2#+timesDoubleX2# = let x = x in x++-- | Multiply two vectors element-wise. ++timesFloatX8# :: FloatX8# -> FloatX8# -> FloatX8#+timesFloatX8# = let x = x in x++-- | Multiply two vectors element-wise. ++timesDoubleX4# :: DoubleX4# -> DoubleX4# -> DoubleX4#+timesDoubleX4# = let x = x in x++-- | Multiply two vectors element-wise. ++timesFloatX16# :: FloatX16# -> FloatX16# -> FloatX16#+timesFloatX16# = let x = x in x++-- | Multiply two vectors element-wise. ++timesDoubleX8# :: DoubleX8# -> DoubleX8# -> DoubleX8#+timesDoubleX8# = let x = x in x++-- | Divide two vectors element-wise. ++divideFloatX4# :: FloatX4# -> FloatX4# -> FloatX4#+divideFloatX4# = let x = x in x++-- | Divide two vectors element-wise. ++divideDoubleX2# :: DoubleX2# -> DoubleX2# -> DoubleX2#+divideDoubleX2# = let x = x in x++-- | Divide two vectors element-wise. ++divideFloatX8# :: FloatX8# -> FloatX8# -> FloatX8#+divideFloatX8# = let x = x in x++-- | Divide two vectors element-wise. ++divideDoubleX4# :: DoubleX4# -> DoubleX4# -> DoubleX4#+divideDoubleX4# = let x = x in x++-- | Divide two vectors element-wise. ++divideFloatX16# :: FloatX16# -> FloatX16# -> FloatX16#+divideFloatX16# = let x = x in x++-- | Divide two vectors element-wise. ++divideDoubleX8# :: DoubleX8# -> DoubleX8# -> DoubleX8#+divideDoubleX8# = let x = x in x++-- | Rounds towards zero element-wise. ++quotInt8X16# :: Int8X16# -> Int8X16# -> Int8X16#+quotInt8X16# = let x = x in x++-- | Rounds towards zero element-wise. ++quotInt16X8# :: Int16X8# -> Int16X8# -> Int16X8#+quotInt16X8# = let x = x in x++-- | Rounds towards zero element-wise. ++quotInt32X4# :: Int32X4# -> Int32X4# -> Int32X4#+quotInt32X4# = let x = x in x++-- | Rounds towards zero element-wise. ++quotInt64X2# :: Int64X2# -> Int64X2# -> Int64X2#+quotInt64X2# = let x = x in x++-- | Rounds towards zero element-wise. ++quotInt8X32# :: Int8X32# -> Int8X32# -> Int8X32#+quotInt8X32# = let x = x in x++-- | Rounds towards zero element-wise. ++quotInt16X16# :: Int16X16# -> Int16X16# -> Int16X16#+quotInt16X16# = let x = x in x++-- | Rounds towards zero element-wise. ++quotInt32X8# :: Int32X8# -> Int32X8# -> Int32X8#+quotInt32X8# = let x = x in x++-- | Rounds towards zero element-wise. ++quotInt64X4# :: Int64X4# -> Int64X4# -> Int64X4#+quotInt64X4# = let x = x in x++-- | Rounds towards zero element-wise. ++quotInt8X64# :: Int8X64# -> Int8X64# -> Int8X64#+quotInt8X64# = let x = x in x++-- | Rounds towards zero element-wise. ++quotInt16X32# :: Int16X32# -> Int16X32# -> Int16X32#+quotInt16X32# = let x = x in x++-- | Rounds towards zero element-wise. ++quotInt32X16# :: Int32X16# -> Int32X16# -> Int32X16#+quotInt32X16# = let x = x in x++-- | Rounds towards zero element-wise. ++quotInt64X8# :: Int64X8# -> Int64X8# -> Int64X8#+quotInt64X8# = let x = x in x++-- | Rounds towards zero element-wise. ++quotWord8X16# :: Word8X16# -> Word8X16# -> Word8X16#+quotWord8X16# = let x = x in x++-- | Rounds towards zero element-wise. ++quotWord16X8# :: Word16X8# -> Word16X8# -> Word16X8#+quotWord16X8# = let x = x in x++-- | Rounds towards zero element-wise. ++quotWord32X4# :: Word32X4# -> Word32X4# -> Word32X4#+quotWord32X4# = let x = x in x++-- | Rounds towards zero element-wise. ++quotWord64X2# :: Word64X2# -> Word64X2# -> Word64X2#+quotWord64X2# = let x = x in x++-- | Rounds towards zero element-wise. ++quotWord8X32# :: Word8X32# -> Word8X32# -> Word8X32#+quotWord8X32# = let x = x in x++-- | Rounds towards zero element-wise. ++quotWord16X16# :: Word16X16# -> Word16X16# -> Word16X16#+quotWord16X16# = let x = x in x++-- | Rounds towards zero element-wise. ++quotWord32X8# :: Word32X8# -> Word32X8# -> Word32X8#+quotWord32X8# = let x = x in x++-- | Rounds towards zero element-wise. ++quotWord64X4# :: Word64X4# -> Word64X4# -> Word64X4#+quotWord64X4# = let x = x in x++-- | Rounds towards zero element-wise. ++quotWord8X64# :: Word8X64# -> Word8X64# -> Word8X64#+quotWord8X64# = let x = x in x++-- | Rounds towards zero element-wise. ++quotWord16X32# :: Word16X32# -> Word16X32# -> Word16X32#+quotWord16X32# = let x = x in x++-- | Rounds towards zero element-wise. ++quotWord32X16# :: Word32X16# -> Word32X16# -> Word32X16#+quotWord32X16# = let x = x in x++-- | Rounds towards zero element-wise. ++quotWord64X8# :: Word64X8# -> Word64X8# -> Word64X8#+quotWord64X8# = let x = x in x++-- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. ++remInt8X16# :: Int8X16# -> Int8X16# -> Int8X16#+remInt8X16# = let x = x in x++-- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. ++remInt16X8# :: Int16X8# -> Int16X8# -> Int16X8#+remInt16X8# = let x = x in x++-- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. ++remInt32X4# :: Int32X4# -> Int32X4# -> Int32X4#+remInt32X4# = let x = x in x++-- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. ++remInt64X2# :: Int64X2# -> Int64X2# -> Int64X2#+remInt64X2# = let x = x in x++-- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. ++remInt8X32# :: Int8X32# -> Int8X32# -> Int8X32#+remInt8X32# = let x = x in x++-- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. ++remInt16X16# :: Int16X16# -> Int16X16# -> Int16X16#+remInt16X16# = let x = x in x++-- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. ++remInt32X8# :: Int32X8# -> Int32X8# -> Int32X8#+remInt32X8# = let x = x in x++-- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. ++remInt64X4# :: Int64X4# -> Int64X4# -> Int64X4#+remInt64X4# = let x = x in x++-- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. ++remInt8X64# :: Int8X64# -> Int8X64# -> Int8X64#+remInt8X64# = let x = x in x++-- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. ++remInt16X32# :: Int16X32# -> Int16X32# -> Int16X32#+remInt16X32# = let x = x in x++-- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. ++remInt32X16# :: Int32X16# -> Int32X16# -> Int32X16#+remInt32X16# = let x = x in x++-- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. ++remInt64X8# :: Int64X8# -> Int64X8# -> Int64X8#+remInt64X8# = let x = x in x++-- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. ++remWord8X16# :: Word8X16# -> Word8X16# -> Word8X16#+remWord8X16# = let x = x in x++-- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. ++remWord16X8# :: Word16X8# -> Word16X8# -> Word16X8#+remWord16X8# = let x = x in x++-- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. ++remWord32X4# :: Word32X4# -> Word32X4# -> Word32X4#+remWord32X4# = let x = x in x++-- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. ++remWord64X2# :: Word64X2# -> Word64X2# -> Word64X2#+remWord64X2# = let x = x in x++-- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. ++remWord8X32# :: Word8X32# -> Word8X32# -> Word8X32#+remWord8X32# = let x = x in x++-- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. ++remWord16X16# :: Word16X16# -> Word16X16# -> Word16X16#+remWord16X16# = let x = x in x++-- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. ++remWord32X8# :: Word32X8# -> Word32X8# -> Word32X8#+remWord32X8# = let x = x in x++-- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. ++remWord64X4# :: Word64X4# -> Word64X4# -> Word64X4#+remWord64X4# = let x = x in x++-- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. ++remWord8X64# :: Word8X64# -> Word8X64# -> Word8X64#+remWord8X64# = let x = x in x++-- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. ++remWord16X32# :: Word16X32# -> Word16X32# -> Word16X32#+remWord16X32# = let x = x in x++-- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. ++remWord32X16# :: Word32X16# -> Word32X16# -> Word32X16#+remWord32X16# = let x = x in x++-- | Satisfies @(quot\# x y) times\# y plus\# (rem\# x y) == x@. ++remWord64X8# :: Word64X8# -> Word64X8# -> Word64X8#+remWord64X8# = let x = x in x++-- | Negate element-wise. ++negateInt8X16# :: Int8X16# -> Int8X16#+negateInt8X16# = let x = x in x++-- | Negate element-wise. ++negateInt16X8# :: Int16X8# -> Int16X8#+negateInt16X8# = let x = x in x++-- | Negate element-wise. ++negateInt32X4# :: Int32X4# -> Int32X4#+negateInt32X4# = let x = x in x++-- | Negate element-wise. ++negateInt64X2# :: Int64X2# -> Int64X2#+negateInt64X2# = let x = x in x++-- | Negate element-wise. ++negateInt8X32# :: Int8X32# -> Int8X32#+negateInt8X32# = let x = x in x++-- | Negate element-wise. ++negateInt16X16# :: Int16X16# -> Int16X16#+negateInt16X16# = let x = x in x++-- | Negate element-wise. ++negateInt32X8# :: Int32X8# -> Int32X8#+negateInt32X8# = let x = x in x++-- | Negate element-wise. ++negateInt64X4# :: Int64X4# -> Int64X4#+negateInt64X4# = let x = x in x++-- | Negate element-wise. ++negateInt8X64# :: Int8X64# -> Int8X64#+negateInt8X64# = let x = x in x++-- | Negate element-wise. ++negateInt16X32# :: Int16X32# -> Int16X32#+negateInt16X32# = let x = x in x++-- | Negate element-wise. ++negateInt32X16# :: Int32X16# -> Int32X16#+negateInt32X16# = let x = x in x++-- | Negate element-wise. ++negateInt64X8# :: Int64X8# -> Int64X8#+negateInt64X8# = let x = x in x++-- | Negate element-wise. ++negateFloatX4# :: FloatX4# -> FloatX4#+negateFloatX4# = let x = x in x++-- | Negate element-wise. ++negateDoubleX2# :: DoubleX2# -> DoubleX2#+negateDoubleX2# = let x = x in x++-- | Negate element-wise. ++negateFloatX8# :: FloatX8# -> FloatX8#+negateFloatX8# = let x = x in x++-- | Negate element-wise. ++negateDoubleX4# :: DoubleX4# -> DoubleX4#+negateDoubleX4# = let x = x in x++-- | Negate element-wise. ++negateFloatX16# :: FloatX16# -> FloatX16#+negateFloatX16# = let x = x in x++-- | Negate element-wise. ++negateDoubleX8# :: DoubleX8# -> DoubleX8#+negateDoubleX8# = let x = x in x++-- | Read a vector from specified index of immutable array. ++indexInt8X16Array# :: ByteArray# -> Int# -> Int8X16#+indexInt8X16Array# = let x = x in x++-- | Read a vector from specified index of immutable array. ++indexInt16X8Array# :: ByteArray# -> Int# -> Int16X8#+indexInt16X8Array# = let x = x in x++-- | Read a vector from specified index of immutable array. ++indexInt32X4Array# :: ByteArray# -> Int# -> Int32X4#+indexInt32X4Array# = let x = x in x++-- | Read a vector from specified index of immutable array. ++indexInt64X2Array# :: ByteArray# -> Int# -> Int64X2#+indexInt64X2Array# = let x = x in x++-- | Read a vector from specified index of immutable array. ++indexInt8X32Array# :: ByteArray# -> Int# -> Int8X32#+indexInt8X32Array# = let x = x in x++-- | Read a vector from specified index of immutable array. ++indexInt16X16Array# :: ByteArray# -> Int# -> Int16X16#+indexInt16X16Array# = let x = x in x++-- | Read a vector from specified index of immutable array. ++indexInt32X8Array# :: ByteArray# -> Int# -> Int32X8#+indexInt32X8Array# = let x = x in x++-- | Read a vector from specified index of immutable array. ++indexInt64X4Array# :: ByteArray# -> Int# -> Int64X4#+indexInt64X4Array# = let x = x in x++-- | Read a vector from specified index of immutable array. ++indexInt8X64Array# :: ByteArray# -> Int# -> Int8X64#+indexInt8X64Array# = let x = x in x++-- | Read a vector from specified index of immutable array. ++indexInt16X32Array# :: ByteArray# -> Int# -> Int16X32#+indexInt16X32Array# = let x = x in x++-- | Read a vector from specified index of immutable array. ++indexInt32X16Array# :: ByteArray# -> Int# -> Int32X16#+indexInt32X16Array# = let x = x in x++-- | Read a vector from specified index of immutable array. ++indexInt64X8Array# :: ByteArray# -> Int# -> Int64X8#+indexInt64X8Array# = let x = x in x++-- | Read a vector from specified index of immutable array. ++indexWord8X16Array# :: ByteArray# -> Int# -> Word8X16#+indexWord8X16Array# = let x = x in x++-- | Read a vector from specified index of immutable array. ++indexWord16X8Array# :: ByteArray# -> Int# -> Word16X8#+indexWord16X8Array# = let x = x in x++-- | Read a vector from specified index of immutable array. ++indexWord32X4Array# :: ByteArray# -> Int# -> Word32X4#+indexWord32X4Array# = let x = x in x++-- | Read a vector from specified index of immutable array. ++indexWord64X2Array# :: ByteArray# -> Int# -> Word64X2#+indexWord64X2Array# = let x = x in x++-- | Read a vector from specified index of immutable array. ++indexWord8X32Array# :: ByteArray# -> Int# -> Word8X32#+indexWord8X32Array# = let x = x in x++-- | Read a vector from specified index of immutable array. ++indexWord16X16Array# :: ByteArray# -> Int# -> Word16X16#+indexWord16X16Array# = let x = x in x++-- | Read a vector from specified index of immutable array. ++indexWord32X8Array# :: ByteArray# -> Int# -> Word32X8#+indexWord32X8Array# = let x = x in x++-- | Read a vector from specified index of immutable array. ++indexWord64X4Array# :: ByteArray# -> Int# -> Word64X4#+indexWord64X4Array# = let x = x in x++-- | Read a vector from specified index of immutable array. ++indexWord8X64Array# :: ByteArray# -> Int# -> Word8X64#+indexWord8X64Array# = let x = x in x++-- | Read a vector from specified index of immutable array. ++indexWord16X32Array# :: ByteArray# -> Int# -> Word16X32#+indexWord16X32Array# = let x = x in x++-- | Read a vector from specified index of immutable array. ++indexWord32X16Array# :: ByteArray# -> Int# -> Word32X16#+indexWord32X16Array# = let x = x in x++-- | Read a vector from specified index of immutable array. ++indexWord64X8Array# :: ByteArray# -> Int# -> Word64X8#+indexWord64X8Array# = let x = x in x++-- | Read a vector from specified index of immutable array. ++indexFloatX4Array# :: ByteArray# -> Int# -> FloatX4#+indexFloatX4Array# = let x = x in x++-- | Read a vector from specified index of immutable array. ++indexDoubleX2Array# :: ByteArray# -> Int# -> DoubleX2#+indexDoubleX2Array# = let x = x in x++-- | Read a vector from specified index of immutable array. ++indexFloatX8Array# :: ByteArray# -> Int# -> FloatX8#+indexFloatX8Array# = let x = x in x++-- | Read a vector from specified index of immutable array. ++indexDoubleX4Array# :: ByteArray# -> Int# -> DoubleX4#+indexDoubleX4Array# = let x = x in x++-- | Read a vector from specified index of immutable array. ++indexFloatX16Array# :: ByteArray# -> Int# -> FloatX16#+indexFloatX16Array# = let x = x in x++-- | Read a vector from specified index of immutable array. ++indexDoubleX8Array# :: ByteArray# -> Int# -> DoubleX8#+indexDoubleX8Array# = let x = x in x++-- | Read a vector from specified index of mutable array. ++readInt8X16Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int8X16# #)+readInt8X16Array# = let x = x in x++-- | Read a vector from specified index of mutable array. ++readInt16X8Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int16X8# #)+readInt16X8Array# = let x = x in x++-- | Read a vector from specified index of mutable array. ++readInt32X4Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int32X4# #)+readInt32X4Array# = let x = x in x++-- | Read a vector from specified index of mutable array. ++readInt64X2Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int64X2# #)+readInt64X2Array# = let x = x in x++-- | Read a vector from specified index of mutable array. ++readInt8X32Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int8X32# #)+readInt8X32Array# = let x = x in x++-- | Read a vector from specified index of mutable array. ++readInt16X16Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int16X16# #)+readInt16X16Array# = let x = x in x++-- | Read a vector from specified index of mutable array. ++readInt32X8Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int32X8# #)+readInt32X8Array# = let x = x in x++-- | Read a vector from specified index of mutable array. ++readInt64X4Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int64X4# #)+readInt64X4Array# = let x = x in x++-- | Read a vector from specified index of mutable array. ++readInt8X64Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int8X64# #)+readInt8X64Array# = let x = x in x++-- | Read a vector from specified index of mutable array. ++readInt16X32Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int16X32# #)+readInt16X32Array# = let x = x in x++-- | Read a vector from specified index of mutable array. ++readInt32X16Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int32X16# #)+readInt32X16Array# = let x = x in x++-- | Read a vector from specified index of mutable array. ++readInt64X8Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int64X8# #)+readInt64X8Array# = let x = x in x++-- | Read a vector from specified index of mutable array. ++readWord8X16Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word8X16# #)+readWord8X16Array# = let x = x in x++-- | Read a vector from specified index of mutable array. ++readWord16X8Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word16X8# #)+readWord16X8Array# = let x = x in x++-- | Read a vector from specified index of mutable array. ++readWord32X4Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word32X4# #)+readWord32X4Array# = let x = x in x++-- | Read a vector from specified index of mutable array. ++readWord64X2Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word64X2# #)+readWord64X2Array# = let x = x in x++-- | Read a vector from specified index of mutable array. ++readWord8X32Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word8X32# #)+readWord8X32Array# = let x = x in x++-- | Read a vector from specified index of mutable array. ++readWord16X16Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word16X16# #)+readWord16X16Array# = let x = x in x++-- | Read a vector from specified index of mutable array. ++readWord32X8Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word32X8# #)+readWord32X8Array# = let x = x in x++-- | Read a vector from specified index of mutable array. ++readWord64X4Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word64X4# #)+readWord64X4Array# = let x = x in x++-- | Read a vector from specified index of mutable array. ++readWord8X64Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word8X64# #)+readWord8X64Array# = let x = x in x++-- | Read a vector from specified index of mutable array. ++readWord16X32Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word16X32# #)+readWord16X32Array# = let x = x in x++-- | Read a vector from specified index of mutable array. ++readWord32X16Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word32X16# #)+readWord32X16Array# = let x = x in x++-- | Read a vector from specified index of mutable array. ++readWord64X8Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word64X8# #)+readWord64X8Array# = let x = x in x++-- | Read a vector from specified index of mutable array. ++readFloatX4Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,FloatX4# #)+readFloatX4Array# = let x = x in x++-- | Read a vector from specified index of mutable array. ++readDoubleX2Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,DoubleX2# #)+readDoubleX2Array# = let x = x in x++-- | Read a vector from specified index of mutable array. ++readFloatX8Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,FloatX8# #)+readFloatX8Array# = let x = x in x++-- | Read a vector from specified index of mutable array. ++readDoubleX4Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,DoubleX4# #)+readDoubleX4Array# = let x = x in x++-- | Read a vector from specified index of mutable array. ++readFloatX16Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,FloatX16# #)+readFloatX16Array# = let x = x in x++-- | Read a vector from specified index of mutable array. ++readDoubleX8Array# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,DoubleX8# #)+readDoubleX8Array# = let x = x in x++-- | Write a vector to specified index of mutable array. ++writeInt8X16Array# :: MutableByteArray# s -> Int# -> Int8X16# -> State# s -> State# s+writeInt8X16Array# = let x = x in x++-- | Write a vector to specified index of mutable array. ++writeInt16X8Array# :: MutableByteArray# s -> Int# -> Int16X8# -> State# s -> State# s+writeInt16X8Array# = let x = x in x++-- | Write a vector to specified index of mutable array. ++writeInt32X4Array# :: MutableByteArray# s -> Int# -> Int32X4# -> State# s -> State# s+writeInt32X4Array# = let x = x in x++-- | Write a vector to specified index of mutable array. ++writeInt64X2Array# :: MutableByteArray# s -> Int# -> Int64X2# -> State# s -> State# s+writeInt64X2Array# = let x = x in x++-- | Write a vector to specified index of mutable array. ++writeInt8X32Array# :: MutableByteArray# s -> Int# -> Int8X32# -> State# s -> State# s+writeInt8X32Array# = let x = x in x++-- | Write a vector to specified index of mutable array. ++writeInt16X16Array# :: MutableByteArray# s -> Int# -> Int16X16# -> State# s -> State# s+writeInt16X16Array# = let x = x in x++-- | Write a vector to specified index of mutable array. ++writeInt32X8Array# :: MutableByteArray# s -> Int# -> Int32X8# -> State# s -> State# s+writeInt32X8Array# = let x = x in x++-- | Write a vector to specified index of mutable array. ++writeInt64X4Array# :: MutableByteArray# s -> Int# -> Int64X4# -> State# s -> State# s+writeInt64X4Array# = let x = x in x++-- | Write a vector to specified index of mutable array. ++writeInt8X64Array# :: MutableByteArray# s -> Int# -> Int8X64# -> State# s -> State# s+writeInt8X64Array# = let x = x in x++-- | Write a vector to specified index of mutable array. ++writeInt16X32Array# :: MutableByteArray# s -> Int# -> Int16X32# -> State# s -> State# s+writeInt16X32Array# = let x = x in x++-- | Write a vector to specified index of mutable array. ++writeInt32X16Array# :: MutableByteArray# s -> Int# -> Int32X16# -> State# s -> State# s+writeInt32X16Array# = let x = x in x++-- | Write a vector to specified index of mutable array. ++writeInt64X8Array# :: MutableByteArray# s -> Int# -> Int64X8# -> State# s -> State# s+writeInt64X8Array# = let x = x in x++-- | Write a vector to specified index of mutable array. ++writeWord8X16Array# :: MutableByteArray# s -> Int# -> Word8X16# -> State# s -> State# s+writeWord8X16Array# = let x = x in x++-- | Write a vector to specified index of mutable array. ++writeWord16X8Array# :: MutableByteArray# s -> Int# -> Word16X8# -> State# s -> State# s+writeWord16X8Array# = let x = x in x++-- | Write a vector to specified index of mutable array. ++writeWord32X4Array# :: MutableByteArray# s -> Int# -> Word32X4# -> State# s -> State# s+writeWord32X4Array# = let x = x in x++-- | Write a vector to specified index of mutable array. ++writeWord64X2Array# :: MutableByteArray# s -> Int# -> Word64X2# -> State# s -> State# s+writeWord64X2Array# = let x = x in x++-- | Write a vector to specified index of mutable array. ++writeWord8X32Array# :: MutableByteArray# s -> Int# -> Word8X32# -> State# s -> State# s+writeWord8X32Array# = let x = x in x++-- | Write a vector to specified index of mutable array. ++writeWord16X16Array# :: MutableByteArray# s -> Int# -> Word16X16# -> State# s -> State# s+writeWord16X16Array# = let x = x in x++-- | Write a vector to specified index of mutable array. ++writeWord32X8Array# :: MutableByteArray# s -> Int# -> Word32X8# -> State# s -> State# s+writeWord32X8Array# = let x = x in x++-- | Write a vector to specified index of mutable array. ++writeWord64X4Array# :: MutableByteArray# s -> Int# -> Word64X4# -> State# s -> State# s+writeWord64X4Array# = let x = x in x++-- | Write a vector to specified index of mutable array. ++writeWord8X64Array# :: MutableByteArray# s -> Int# -> Word8X64# -> State# s -> State# s+writeWord8X64Array# = let x = x in x++-- | Write a vector to specified index of mutable array. ++writeWord16X32Array# :: MutableByteArray# s -> Int# -> Word16X32# -> State# s -> State# s+writeWord16X32Array# = let x = x in x++-- | Write a vector to specified index of mutable array. ++writeWord32X16Array# :: MutableByteArray# s -> Int# -> Word32X16# -> State# s -> State# s+writeWord32X16Array# = let x = x in x++-- | Write a vector to specified index of mutable array. ++writeWord64X8Array# :: MutableByteArray# s -> Int# -> Word64X8# -> State# s -> State# s+writeWord64X8Array# = let x = x in x++-- | Write a vector to specified index of mutable array. ++writeFloatX4Array# :: MutableByteArray# s -> Int# -> FloatX4# -> State# s -> State# s+writeFloatX4Array# = let x = x in x++-- | Write a vector to specified index of mutable array. ++writeDoubleX2Array# :: MutableByteArray# s -> Int# -> DoubleX2# -> State# s -> State# s+writeDoubleX2Array# = let x = x in x++-- | Write a vector to specified index of mutable array. ++writeFloatX8Array# :: MutableByteArray# s -> Int# -> FloatX8# -> State# s -> State# s+writeFloatX8Array# = let x = x in x++-- | Write a vector to specified index of mutable array. ++writeDoubleX4Array# :: MutableByteArray# s -> Int# -> DoubleX4# -> State# s -> State# s+writeDoubleX4Array# = let x = x in x++-- | Write a vector to specified index of mutable array. ++writeFloatX16Array# :: MutableByteArray# s -> Int# -> FloatX16# -> State# s -> State# s+writeFloatX16Array# = let x = x in x++-- | Write a vector to specified index of mutable array. ++writeDoubleX8Array# :: MutableByteArray# s -> Int# -> DoubleX8# -> State# s -> State# s+writeDoubleX8Array# = let x = x in x++-- | Reads vector; offset in bytes. ++indexInt8X16OffAddr# :: Addr# -> Int# -> Int8X16#+indexInt8X16OffAddr# = let x = x in x++-- | Reads vector; offset in bytes. ++indexInt16X8OffAddr# :: Addr# -> Int# -> Int16X8#+indexInt16X8OffAddr# = let x = x in x++-- | Reads vector; offset in bytes. ++indexInt32X4OffAddr# :: Addr# -> Int# -> Int32X4#+indexInt32X4OffAddr# = let x = x in x++-- | Reads vector; offset in bytes. ++indexInt64X2OffAddr# :: Addr# -> Int# -> Int64X2#+indexInt64X2OffAddr# = let x = x in x++-- | Reads vector; offset in bytes. ++indexInt8X32OffAddr# :: Addr# -> Int# -> Int8X32#+indexInt8X32OffAddr# = let x = x in x++-- | Reads vector; offset in bytes. ++indexInt16X16OffAddr# :: Addr# -> Int# -> Int16X16#+indexInt16X16OffAddr# = let x = x in x++-- | Reads vector; offset in bytes. ++indexInt32X8OffAddr# :: Addr# -> Int# -> Int32X8#+indexInt32X8OffAddr# = let x = x in x++-- | Reads vector; offset in bytes. ++indexInt64X4OffAddr# :: Addr# -> Int# -> Int64X4#+indexInt64X4OffAddr# = let x = x in x++-- | Reads vector; offset in bytes. ++indexInt8X64OffAddr# :: Addr# -> Int# -> Int8X64#+indexInt8X64OffAddr# = let x = x in x++-- | Reads vector; offset in bytes. ++indexInt16X32OffAddr# :: Addr# -> Int# -> Int16X32#+indexInt16X32OffAddr# = let x = x in x++-- | Reads vector; offset in bytes. ++indexInt32X16OffAddr# :: Addr# -> Int# -> Int32X16#+indexInt32X16OffAddr# = let x = x in x++-- | Reads vector; offset in bytes. ++indexInt64X8OffAddr# :: Addr# -> Int# -> Int64X8#+indexInt64X8OffAddr# = let x = x in x++-- | Reads vector; offset in bytes. ++indexWord8X16OffAddr# :: Addr# -> Int# -> Word8X16#+indexWord8X16OffAddr# = let x = x in x++-- | Reads vector; offset in bytes. ++indexWord16X8OffAddr# :: Addr# -> Int# -> Word16X8#+indexWord16X8OffAddr# = let x = x in x++-- | Reads vector; offset in bytes. ++indexWord32X4OffAddr# :: Addr# -> Int# -> Word32X4#+indexWord32X4OffAddr# = let x = x in x++-- | Reads vector; offset in bytes. ++indexWord64X2OffAddr# :: Addr# -> Int# -> Word64X2#+indexWord64X2OffAddr# = let x = x in x++-- | Reads vector; offset in bytes. ++indexWord8X32OffAddr# :: Addr# -> Int# -> Word8X32#+indexWord8X32OffAddr# = let x = x in x++-- | Reads vector; offset in bytes. ++indexWord16X16OffAddr# :: Addr# -> Int# -> Word16X16#+indexWord16X16OffAddr# = let x = x in x++-- | Reads vector; offset in bytes. ++indexWord32X8OffAddr# :: Addr# -> Int# -> Word32X8#+indexWord32X8OffAddr# = let x = x in x++-- | Reads vector; offset in bytes. ++indexWord64X4OffAddr# :: Addr# -> Int# -> Word64X4#+indexWord64X4OffAddr# = let x = x in x++-- | Reads vector; offset in bytes. ++indexWord8X64OffAddr# :: Addr# -> Int# -> Word8X64#+indexWord8X64OffAddr# = let x = x in x++-- | Reads vector; offset in bytes. ++indexWord16X32OffAddr# :: Addr# -> Int# -> Word16X32#+indexWord16X32OffAddr# = let x = x in x++-- | Reads vector; offset in bytes. ++indexWord32X16OffAddr# :: Addr# -> Int# -> Word32X16#+indexWord32X16OffAddr# = let x = x in x++-- | Reads vector; offset in bytes. ++indexWord64X8OffAddr# :: Addr# -> Int# -> Word64X8#+indexWord64X8OffAddr# = let x = x in x++-- | Reads vector; offset in bytes. ++indexFloatX4OffAddr# :: Addr# -> Int# -> FloatX4#+indexFloatX4OffAddr# = let x = x in x++-- | Reads vector; offset in bytes. ++indexDoubleX2OffAddr# :: Addr# -> Int# -> DoubleX2#+indexDoubleX2OffAddr# = let x = x in x++-- | Reads vector; offset in bytes. ++indexFloatX8OffAddr# :: Addr# -> Int# -> FloatX8#+indexFloatX8OffAddr# = let x = x in x++-- | Reads vector; offset in bytes. ++indexDoubleX4OffAddr# :: Addr# -> Int# -> DoubleX4#+indexDoubleX4OffAddr# = let x = x in x++-- | Reads vector; offset in bytes. ++indexFloatX16OffAddr# :: Addr# -> Int# -> FloatX16#+indexFloatX16OffAddr# = let x = x in x++-- | Reads vector; offset in bytes. ++indexDoubleX8OffAddr# :: Addr# -> Int# -> DoubleX8#+indexDoubleX8OffAddr# = let x = x in x++-- | Reads vector; offset in bytes. ++readInt8X16OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int8X16# #)+readInt8X16OffAddr# = let x = x in x++-- | Reads vector; offset in bytes. ++readInt16X8OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int16X8# #)+readInt16X8OffAddr# = let x = x in x++-- | Reads vector; offset in bytes. ++readInt32X4OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int32X4# #)+readInt32X4OffAddr# = let x = x in x++-- | Reads vector; offset in bytes. ++readInt64X2OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int64X2# #)+readInt64X2OffAddr# = let x = x in x++-- | Reads vector; offset in bytes. ++readInt8X32OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int8X32# #)+readInt8X32OffAddr# = let x = x in x++-- | Reads vector; offset in bytes. ++readInt16X16OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int16X16# #)+readInt16X16OffAddr# = let x = x in x++-- | Reads vector; offset in bytes. ++readInt32X8OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int32X8# #)+readInt32X8OffAddr# = let x = x in x++-- | Reads vector; offset in bytes. ++readInt64X4OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int64X4# #)+readInt64X4OffAddr# = let x = x in x++-- | Reads vector; offset in bytes. ++readInt8X64OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int8X64# #)+readInt8X64OffAddr# = let x = x in x++-- | Reads vector; offset in bytes. ++readInt16X32OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int16X32# #)+readInt16X32OffAddr# = let x = x in x++-- | Reads vector; offset in bytes. ++readInt32X16OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int32X16# #)+readInt32X16OffAddr# = let x = x in x++-- | Reads vector; offset in bytes. ++readInt64X8OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Int64X8# #)+readInt64X8OffAddr# = let x = x in x++-- | Reads vector; offset in bytes. ++readWord8X16OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word8X16# #)+readWord8X16OffAddr# = let x = x in x++-- | Reads vector; offset in bytes. ++readWord16X8OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word16X8# #)+readWord16X8OffAddr# = let x = x in x++-- | Reads vector; offset in bytes. ++readWord32X4OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word32X4# #)+readWord32X4OffAddr# = let x = x in x++-- | Reads vector; offset in bytes. ++readWord64X2OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word64X2# #)+readWord64X2OffAddr# = let x = x in x++-- | Reads vector; offset in bytes. ++readWord8X32OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word8X32# #)+readWord8X32OffAddr# = let x = x in x++-- | Reads vector; offset in bytes. ++readWord16X16OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word16X16# #)+readWord16X16OffAddr# = let x = x in x++-- | Reads vector; offset in bytes. ++readWord32X8OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word32X8# #)+readWord32X8OffAddr# = let x = x in x++-- | Reads vector; offset in bytes. ++readWord64X4OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word64X4# #)+readWord64X4OffAddr# = let x = x in x++-- | Reads vector; offset in bytes. ++readWord8X64OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word8X64# #)+readWord8X64OffAddr# = let x = x in x++-- | Reads vector; offset in bytes. ++readWord16X32OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word16X32# #)+readWord16X32OffAddr# = let x = x in x++-- | Reads vector; offset in bytes. ++readWord32X16OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word32X16# #)+readWord32X16OffAddr# = let x = x in x++-- | Reads vector; offset in bytes. ++readWord64X8OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,Word64X8# #)+readWord64X8OffAddr# = let x = x in x++-- | Reads vector; offset in bytes. ++readFloatX4OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,FloatX4# #)+readFloatX4OffAddr# = let x = x in x++-- | Reads vector; offset in bytes. ++readDoubleX2OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,DoubleX2# #)+readDoubleX2OffAddr# = let x = x in x++-- | Reads vector; offset in bytes. ++readFloatX8OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,FloatX8# #)+readFloatX8OffAddr# = let x = x in x++-- | Reads vector; offset in bytes. ++readDoubleX4OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,DoubleX4# #)+readDoubleX4OffAddr# = let x = x in x++-- | Reads vector; offset in bytes. ++readFloatX16OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,FloatX16# #)+readFloatX16OffAddr# = let x = x in x++-- | Reads vector; offset in bytes. ++readDoubleX8OffAddr# :: Addr# -> Int# -> State# s -> (# State# s,DoubleX8# #)+readDoubleX8OffAddr# = let x = x in x++-- | Write vector; offset in bytes. ++writeInt8X16OffAddr# :: Addr# -> Int# -> Int8X16# -> State# s -> State# s+writeInt8X16OffAddr# = let x = x in x++-- | Write vector; offset in bytes. ++writeInt16X8OffAddr# :: Addr# -> Int# -> Int16X8# -> State# s -> State# s+writeInt16X8OffAddr# = let x = x in x++-- | Write vector; offset in bytes. ++writeInt32X4OffAddr# :: Addr# -> Int# -> Int32X4# -> State# s -> State# s+writeInt32X4OffAddr# = let x = x in x++-- | Write vector; offset in bytes. ++writeInt64X2OffAddr# :: Addr# -> Int# -> Int64X2# -> State# s -> State# s+writeInt64X2OffAddr# = let x = x in x++-- | Write vector; offset in bytes. ++writeInt8X32OffAddr# :: Addr# -> Int# -> Int8X32# -> State# s -> State# s+writeInt8X32OffAddr# = let x = x in x++-- | Write vector; offset in bytes. ++writeInt16X16OffAddr# :: Addr# -> Int# -> Int16X16# -> State# s -> State# s+writeInt16X16OffAddr# = let x = x in x++-- | Write vector; offset in bytes. ++writeInt32X8OffAddr# :: Addr# -> Int# -> Int32X8# -> State# s -> State# s+writeInt32X8OffAddr# = let x = x in x++-- | Write vector; offset in bytes. ++writeInt64X4OffAddr# :: Addr# -> Int# -> Int64X4# -> State# s -> State# s+writeInt64X4OffAddr# = let x = x in x++-- | Write vector; offset in bytes. ++writeInt8X64OffAddr# :: Addr# -> Int# -> Int8X64# -> State# s -> State# s+writeInt8X64OffAddr# = let x = x in x++-- | Write vector; offset in bytes. ++writeInt16X32OffAddr# :: Addr# -> Int# -> Int16X32# -> State# s -> State# s+writeInt16X32OffAddr# = let x = x in x++-- | Write vector; offset in bytes. ++writeInt32X16OffAddr# :: Addr# -> Int# -> Int32X16# -> State# s -> State# s+writeInt32X16OffAddr# = let x = x in x++-- | Write vector; offset in bytes. ++writeInt64X8OffAddr# :: Addr# -> Int# -> Int64X8# -> State# s -> State# s+writeInt64X8OffAddr# = let x = x in x++-- | Write vector; offset in bytes. ++writeWord8X16OffAddr# :: Addr# -> Int# -> Word8X16# -> State# s -> State# s+writeWord8X16OffAddr# = let x = x in x++-- | Write vector; offset in bytes. ++writeWord16X8OffAddr# :: Addr# -> Int# -> Word16X8# -> State# s -> State# s+writeWord16X8OffAddr# = let x = x in x++-- | Write vector; offset in bytes. ++writeWord32X4OffAddr# :: Addr# -> Int# -> Word32X4# -> State# s -> State# s+writeWord32X4OffAddr# = let x = x in x++-- | Write vector; offset in bytes. ++writeWord64X2OffAddr# :: Addr# -> Int# -> Word64X2# -> State# s -> State# s+writeWord64X2OffAddr# = let x = x in x++-- | Write vector; offset in bytes. ++writeWord8X32OffAddr# :: Addr# -> Int# -> Word8X32# -> State# s -> State# s+writeWord8X32OffAddr# = let x = x in x++-- | Write vector; offset in bytes. ++writeWord16X16OffAddr# :: Addr# -> Int# -> Word16X16# -> State# s -> State# s+writeWord16X16OffAddr# = let x = x in x++-- | Write vector; offset in bytes. ++writeWord32X8OffAddr# :: Addr# -> Int# -> Word32X8# -> State# s -> State# s+writeWord32X8OffAddr# = let x = x in x++-- | Write vector; offset in bytes. ++writeWord64X4OffAddr# :: Addr# -> Int# -> Word64X4# -> State# s -> State# s+writeWord64X4OffAddr# = let x = x in x++-- | Write vector; offset in bytes. ++writeWord8X64OffAddr# :: Addr# -> Int# -> Word8X64# -> State# s -> State# s+writeWord8X64OffAddr# = let x = x in x++-- | Write vector; offset in bytes. ++writeWord16X32OffAddr# :: Addr# -> Int# -> Word16X32# -> State# s -> State# s+writeWord16X32OffAddr# = let x = x in x++-- | Write vector; offset in bytes. ++writeWord32X16OffAddr# :: Addr# -> Int# -> Word32X16# -> State# s -> State# s+writeWord32X16OffAddr# = let x = x in x++-- | Write vector; offset in bytes. ++writeWord64X8OffAddr# :: Addr# -> Int# -> Word64X8# -> State# s -> State# s+writeWord64X8OffAddr# = let x = x in x++-- | Write vector; offset in bytes. ++writeFloatX4OffAddr# :: Addr# -> Int# -> FloatX4# -> State# s -> State# s+writeFloatX4OffAddr# = let x = x in x++-- | Write vector; offset in bytes. ++writeDoubleX2OffAddr# :: Addr# -> Int# -> DoubleX2# -> State# s -> State# s+writeDoubleX2OffAddr# = let x = x in x++-- | Write vector; offset in bytes. ++writeFloatX8OffAddr# :: Addr# -> Int# -> FloatX8# -> State# s -> State# s+writeFloatX8OffAddr# = let x = x in x++-- | Write vector; offset in bytes. ++writeDoubleX4OffAddr# :: Addr# -> Int# -> DoubleX4# -> State# s -> State# s+writeDoubleX4OffAddr# = let x = x in x++-- | Write vector; offset in bytes. ++writeFloatX16OffAddr# :: Addr# -> Int# -> FloatX16# -> State# s -> State# s+writeFloatX16OffAddr# = let x = x in x++-- | Write vector; offset in bytes. ++writeDoubleX8OffAddr# :: Addr# -> Int# -> DoubleX8# -> State# s -> State# s+writeDoubleX8OffAddr# = let x = x in x++-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. ++indexInt8ArrayAsInt8X16# :: ByteArray# -> Int# -> Int8X16#+indexInt8ArrayAsInt8X16# = let x = x in x++-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. ++indexInt16ArrayAsInt16X8# :: ByteArray# -> Int# -> Int16X8#+indexInt16ArrayAsInt16X8# = let x = x in x++-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. ++indexInt32ArrayAsInt32X4# :: ByteArray# -> Int# -> Int32X4#+indexInt32ArrayAsInt32X4# = let x = x in x++-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. ++indexInt64ArrayAsInt64X2# :: ByteArray# -> Int# -> Int64X2#+indexInt64ArrayAsInt64X2# = let x = x in x++-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. ++indexInt8ArrayAsInt8X32# :: ByteArray# -> Int# -> Int8X32#+indexInt8ArrayAsInt8X32# = let x = x in x++-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. ++indexInt16ArrayAsInt16X16# :: ByteArray# -> Int# -> Int16X16#+indexInt16ArrayAsInt16X16# = let x = x in x++-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. ++indexInt32ArrayAsInt32X8# :: ByteArray# -> Int# -> Int32X8#+indexInt32ArrayAsInt32X8# = let x = x in x++-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. ++indexInt64ArrayAsInt64X4# :: ByteArray# -> Int# -> Int64X4#+indexInt64ArrayAsInt64X4# = let x = x in x++-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. ++indexInt8ArrayAsInt8X64# :: ByteArray# -> Int# -> Int8X64#+indexInt8ArrayAsInt8X64# = let x = x in x++-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. ++indexInt16ArrayAsInt16X32# :: ByteArray# -> Int# -> Int16X32#+indexInt16ArrayAsInt16X32# = let x = x in x++-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. ++indexInt32ArrayAsInt32X16# :: ByteArray# -> Int# -> Int32X16#+indexInt32ArrayAsInt32X16# = let x = x in x++-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. ++indexInt64ArrayAsInt64X8# :: ByteArray# -> Int# -> Int64X8#+indexInt64ArrayAsInt64X8# = let x = x in x++-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. ++indexWord8ArrayAsWord8X16# :: ByteArray# -> Int# -> Word8X16#+indexWord8ArrayAsWord8X16# = let x = x in x++-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. ++indexWord16ArrayAsWord16X8# :: ByteArray# -> Int# -> Word16X8#+indexWord16ArrayAsWord16X8# = let x = x in x++-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. ++indexWord32ArrayAsWord32X4# :: ByteArray# -> Int# -> Word32X4#+indexWord32ArrayAsWord32X4# = let x = x in x++-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. ++indexWord64ArrayAsWord64X2# :: ByteArray# -> Int# -> Word64X2#+indexWord64ArrayAsWord64X2# = let x = x in x++-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. ++indexWord8ArrayAsWord8X32# :: ByteArray# -> Int# -> Word8X32#+indexWord8ArrayAsWord8X32# = let x = x in x++-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. ++indexWord16ArrayAsWord16X16# :: ByteArray# -> Int# -> Word16X16#+indexWord16ArrayAsWord16X16# = let x = x in x++-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. ++indexWord32ArrayAsWord32X8# :: ByteArray# -> Int# -> Word32X8#+indexWord32ArrayAsWord32X8# = let x = x in x++-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. ++indexWord64ArrayAsWord64X4# :: ByteArray# -> Int# -> Word64X4#+indexWord64ArrayAsWord64X4# = let x = x in x++-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. ++indexWord8ArrayAsWord8X64# :: ByteArray# -> Int# -> Word8X64#+indexWord8ArrayAsWord8X64# = let x = x in x++-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. ++indexWord16ArrayAsWord16X32# :: ByteArray# -> Int# -> Word16X32#+indexWord16ArrayAsWord16X32# = let x = x in x++-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. ++indexWord32ArrayAsWord32X16# :: ByteArray# -> Int# -> Word32X16#+indexWord32ArrayAsWord32X16# = let x = x in x++-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. ++indexWord64ArrayAsWord64X8# :: ByteArray# -> Int# -> Word64X8#+indexWord64ArrayAsWord64X8# = let x = x in x++-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. ++indexFloatArrayAsFloatX4# :: ByteArray# -> Int# -> FloatX4#+indexFloatArrayAsFloatX4# = let x = x in x++-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. ++indexDoubleArrayAsDoubleX2# :: ByteArray# -> Int# -> DoubleX2#+indexDoubleArrayAsDoubleX2# = let x = x in x++-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. ++indexFloatArrayAsFloatX8# :: ByteArray# -> Int# -> FloatX8#+indexFloatArrayAsFloatX8# = let x = x in x++-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. ++indexDoubleArrayAsDoubleX4# :: ByteArray# -> Int# -> DoubleX4#+indexDoubleArrayAsDoubleX4# = let x = x in x++-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. ++indexFloatArrayAsFloatX16# :: ByteArray# -> Int# -> FloatX16#+indexFloatArrayAsFloatX16# = let x = x in x++-- | Read a vector from specified index of immutable array of scalars; offset is in scalar elements. ++indexDoubleArrayAsDoubleX8# :: ByteArray# -> Int# -> DoubleX8#+indexDoubleArrayAsDoubleX8# = let x = x in x++-- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. ++readInt8ArrayAsInt8X16# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int8X16# #)+readInt8ArrayAsInt8X16# = let x = x in x++-- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. ++readInt16ArrayAsInt16X8# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int16X8# #)+readInt16ArrayAsInt16X8# = let x = x in x++-- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. ++readInt32ArrayAsInt32X4# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int32X4# #)+readInt32ArrayAsInt32X4# = let x = x in x++-- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. ++readInt64ArrayAsInt64X2# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int64X2# #)+readInt64ArrayAsInt64X2# = let x = x in x++-- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. ++readInt8ArrayAsInt8X32# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int8X32# #)+readInt8ArrayAsInt8X32# = let x = x in x++-- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. ++readInt16ArrayAsInt16X16# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int16X16# #)+readInt16ArrayAsInt16X16# = let x = x in x++-- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. ++readInt32ArrayAsInt32X8# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int32X8# #)+readInt32ArrayAsInt32X8# = let x = x in x++-- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. ++readInt64ArrayAsInt64X4# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int64X4# #)+readInt64ArrayAsInt64X4# = let x = x in x++-- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. ++readInt8ArrayAsInt8X64# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int8X64# #)+readInt8ArrayAsInt8X64# = let x = x in x++-- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. ++readInt16ArrayAsInt16X32# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int16X32# #)+readInt16ArrayAsInt16X32# = let x = x in x++-- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. ++readInt32ArrayAsInt32X16# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int32X16# #)+readInt32ArrayAsInt32X16# = let x = x in x++-- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. ++readInt64ArrayAsInt64X8# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int64X8# #)+readInt64ArrayAsInt64X8# = let x = x in x++-- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. ++readWord8ArrayAsWord8X16# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word8X16# #)+readWord8ArrayAsWord8X16# = let x = x in x++-- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. ++readWord16ArrayAsWord16X8# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word16X8# #)+readWord16ArrayAsWord16X8# = let x = x in x++-- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. ++readWord32ArrayAsWord32X4# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word32X4# #)+readWord32ArrayAsWord32X4# = let x = x in x++-- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. ++readWord64ArrayAsWord64X2# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word64X2# #)+readWord64ArrayAsWord64X2# = let x = x in x++-- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. ++readWord8ArrayAsWord8X32# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word8X32# #)+readWord8ArrayAsWord8X32# = let x = x in x++-- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. ++readWord16ArrayAsWord16X16# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word16X16# #)+readWord16ArrayAsWord16X16# = let x = x in x++-- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. ++readWord32ArrayAsWord32X8# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word32X8# #)+readWord32ArrayAsWord32X8# = let x = x in x++-- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. ++readWord64ArrayAsWord64X4# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word64X4# #)+readWord64ArrayAsWord64X4# = let x = x in x++-- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. ++readWord8ArrayAsWord8X64# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word8X64# #)+readWord8ArrayAsWord8X64# = let x = x in x++-- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. ++readWord16ArrayAsWord16X32# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word16X32# #)+readWord16ArrayAsWord16X32# = let x = x in x++-- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. ++readWord32ArrayAsWord32X16# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word32X16# #)+readWord32ArrayAsWord32X16# = let x = x in x++-- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. ++readWord64ArrayAsWord64X8# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Word64X8# #)+readWord64ArrayAsWord64X8# = let x = x in x++-- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. ++readFloatArrayAsFloatX4# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,FloatX4# #)+readFloatArrayAsFloatX4# = let x = x in x++-- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. ++readDoubleArrayAsDoubleX2# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,DoubleX2# #)+readDoubleArrayAsDoubleX2# = let x = x in x++-- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. ++readFloatArrayAsFloatX8# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,FloatX8# #)+readFloatArrayAsFloatX8# = let x = x in x++-- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. ++readDoubleArrayAsDoubleX4# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,DoubleX4# #)+readDoubleArrayAsDoubleX4# = let x = x in x++-- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. ++readFloatArrayAsFloatX16# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,FloatX16# #)+readFloatArrayAsFloatX16# = let x = x in x++-- | Read a vector from specified index of mutable array of scalars; offset is in scalar elements. ++readDoubleArrayAsDoubleX8# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,DoubleX8# #)+readDoubleArrayAsDoubleX8# = let x = x in x++-- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. ++writeInt8ArrayAsInt8X16# :: MutableByteArray# s -> Int# -> Int8X16# -> State# s -> State# s+writeInt8ArrayAsInt8X16# = let x = x in x++-- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. ++writeInt16ArrayAsInt16X8# :: MutableByteArray# s -> Int# -> Int16X8# -> State# s -> State# s+writeInt16ArrayAsInt16X8# = let x = x in x++-- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. ++writeInt32ArrayAsInt32X4# :: MutableByteArray# s -> Int# -> Int32X4# -> State# s -> State# s+writeInt32ArrayAsInt32X4# = let x = x in x++-- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. ++writeInt64ArrayAsInt64X2# :: MutableByteArray# s -> Int# -> Int64X2# -> State# s -> State# s+writeInt64ArrayAsInt64X2# = let x = x in x++-- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. ++writeInt8ArrayAsInt8X32# :: MutableByteArray# s -> Int# -> Int8X32# -> State# s -> State# s+writeInt8ArrayAsInt8X32# = let x = x in x++-- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. ++writeInt16ArrayAsInt16X16# :: MutableByteArray# s -> Int# -> Int16X16# -> State# s -> State# s+writeInt16ArrayAsInt16X16# = let x = x in x++-- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. ++writeInt32ArrayAsInt32X8# :: MutableByteArray# s -> Int# -> Int32X8# -> State# s -> State# s+writeInt32ArrayAsInt32X8# = let x = x in x++-- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. ++writeInt64ArrayAsInt64X4# :: MutableByteArray# s -> Int# -> Int64X4# -> State# s -> State# s+writeInt64ArrayAsInt64X4# = let x = x in x++-- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. ++writeInt8ArrayAsInt8X64# :: MutableByteArray# s -> Int# -> Int8X64# -> State# s -> State# s+writeInt8ArrayAsInt8X64# = let x = x in x++-- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. ++writeInt16ArrayAsInt16X32# :: MutableByteArray# s -> Int# -> Int16X32# -> State# s -> State# s+writeInt16ArrayAsInt16X32# = let x = x in x++-- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. ++writeInt32ArrayAsInt32X16# :: MutableByteArray# s -> Int# -> Int32X16# -> State# s -> State# s+writeInt32ArrayAsInt32X16# = let x = x in x++-- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. ++writeInt64ArrayAsInt64X8# :: MutableByteArray# s -> Int# -> Int64X8# -> State# s -> State# s+writeInt64ArrayAsInt64X8# = let x = x in x++-- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. ++writeWord8ArrayAsWord8X16# :: MutableByteArray# s -> Int# -> Word8X16# -> State# s -> State# s+writeWord8ArrayAsWord8X16# = let x = x in x++-- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. ++writeWord16ArrayAsWord16X8# :: MutableByteArray# s -> Int# -> Word16X8# -> State# s -> State# s+writeWord16ArrayAsWord16X8# = let x = x in x++-- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. ++writeWord32ArrayAsWord32X4# :: MutableByteArray# s -> Int# -> Word32X4# -> State# s -> State# s+writeWord32ArrayAsWord32X4# = let x = x in x++-- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. ++writeWord64ArrayAsWord64X2# :: MutableByteArray# s -> Int# -> Word64X2# -> State# s -> State# s+writeWord64ArrayAsWord64X2# = let x = x in x++-- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. ++writeWord8ArrayAsWord8X32# :: MutableByteArray# s -> Int# -> Word8X32# -> State# s -> State# s+writeWord8ArrayAsWord8X32# = let x = x in x++-- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. ++writeWord16ArrayAsWord16X16# :: MutableByteArray# s -> Int# -> Word16X16# -> State# s -> State# s+writeWord16ArrayAsWord16X16# = let x = x in x++-- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. ++writeWord32ArrayAsWord32X8# :: MutableByteArray# s -> Int# -> Word32X8# -> State# s -> State# s+writeWord32ArrayAsWord32X8# = let x = x in x++-- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. ++writeWord64ArrayAsWord64X4# :: MutableByteArray# s -> Int# -> Word64X4# -> State# s -> State# s+writeWord64ArrayAsWord64X4# = let x = x in x++-- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. ++writeWord8ArrayAsWord8X64# :: MutableByteArray# s -> Int# -> Word8X64# -> State# s -> State# s+writeWord8ArrayAsWord8X64# = let x = x in x++-- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. ++writeWord16ArrayAsWord16X32# :: MutableByteArray# s -> Int# -> Word16X32# -> State# s -> State# s+writeWord16ArrayAsWord16X32# = let x = x in x++-- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. ++writeWord32ArrayAsWord32X16# :: MutableByteArray# s -> Int# -> Word32X16# -> State# s -> State# s+writeWord32ArrayAsWord32X16# = let x = x in x++-- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. ++writeWord64ArrayAsWord64X8# :: MutableByteArray# s -> Int# -> Word64X8# -> State# s -> State# s+writeWord64ArrayAsWord64X8# = let x = x in x++-- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. ++writeFloatArrayAsFloatX4# :: MutableByteArray# s -> Int# -> FloatX4# -> State# s -> State# s+writeFloatArrayAsFloatX4# = let x = x in x++-- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. ++writeDoubleArrayAsDoubleX2# :: MutableByteArray# s -> Int# -> DoubleX2# -> State# s -> State# s+writeDoubleArrayAsDoubleX2# = let x = x in x++-- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. ++writeFloatArrayAsFloatX8# :: MutableByteArray# s -> Int# -> FloatX8# -> State# s -> State# s+writeFloatArrayAsFloatX8# = let x = x in x++-- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. ++writeDoubleArrayAsDoubleX4# :: MutableByteArray# s -> Int# -> DoubleX4# -> State# s -> State# s+writeDoubleArrayAsDoubleX4# = let x = x in x++-- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. ++writeFloatArrayAsFloatX16# :: MutableByteArray# s -> Int# -> FloatX16# -> State# s -> State# s+writeFloatArrayAsFloatX16# = let x = x in x++-- | Write a vector to specified index of mutable array of scalars; offset is in scalar elements. ++writeDoubleArrayAsDoubleX8# :: MutableByteArray# s -> Int# -> DoubleX8# -> State# s -> State# s+writeDoubleArrayAsDoubleX8# = let x = x in x++-- | Reads vector; offset in scalar elements. ++indexInt8OffAddrAsInt8X16# :: Addr# -> Int# -> Int8X16#+indexInt8OffAddrAsInt8X16# = let x = x in x++-- | Reads vector; offset in scalar elements. ++indexInt16OffAddrAsInt16X8# :: Addr# -> Int# -> Int16X8#+indexInt16OffAddrAsInt16X8# = let x = x in x++-- | Reads vector; offset in scalar elements. ++indexInt32OffAddrAsInt32X4# :: Addr# -> Int# -> Int32X4#+indexInt32OffAddrAsInt32X4# = let x = x in x++-- | Reads vector; offset in scalar elements. ++indexInt64OffAddrAsInt64X2# :: Addr# -> Int# -> Int64X2#+indexInt64OffAddrAsInt64X2# = let x = x in x++-- | Reads vector; offset in scalar elements. ++indexInt8OffAddrAsInt8X32# :: Addr# -> Int# -> Int8X32#+indexInt8OffAddrAsInt8X32# = let x = x in x++-- | Reads vector; offset in scalar elements. ++indexInt16OffAddrAsInt16X16# :: Addr# -> Int# -> Int16X16#+indexInt16OffAddrAsInt16X16# = let x = x in x++-- | Reads vector; offset in scalar elements. ++indexInt32OffAddrAsInt32X8# :: Addr# -> Int# -> Int32X8#+indexInt32OffAddrAsInt32X8# = let x = x in x++-- | Reads vector; offset in scalar elements. ++indexInt64OffAddrAsInt64X4# :: Addr# -> Int# -> Int64X4#+indexInt64OffAddrAsInt64X4# = let x = x in x++-- | Reads vector; offset in scalar elements. ++indexInt8OffAddrAsInt8X64# :: Addr# -> Int# -> Int8X64#+indexInt8OffAddrAsInt8X64# = let x = x in x++-- | Reads vector; offset in scalar elements. ++indexInt16OffAddrAsInt16X32# :: Addr# -> Int# -> Int16X32#+indexInt16OffAddrAsInt16X32# = let x = x in x++-- | Reads vector; offset in scalar elements. ++indexInt32OffAddrAsInt32X16# :: Addr# -> Int# -> Int32X16#+indexInt32OffAddrAsInt32X16# = let x = x in x++-- | Reads vector; offset in scalar elements. ++indexInt64OffAddrAsInt64X8# :: Addr# -> Int# -> Int64X8#+indexInt64OffAddrAsInt64X8# = let x = x in x++-- | Reads vector; offset in scalar elements. ++indexWord8OffAddrAsWord8X16# :: Addr# -> Int# -> Word8X16#+indexWord8OffAddrAsWord8X16# = let x = x in x++-- | Reads vector; offset in scalar elements. ++indexWord16OffAddrAsWord16X8# :: Addr# -> Int# -> Word16X8#+indexWord16OffAddrAsWord16X8# = let x = x in x++-- | Reads vector; offset in scalar elements. ++indexWord32OffAddrAsWord32X4# :: Addr# -> Int# -> Word32X4#+indexWord32OffAddrAsWord32X4# = let x = x in x++-- | Reads vector; offset in scalar elements. ++indexWord64OffAddrAsWord64X2# :: Addr# -> Int# -> Word64X2#+indexWord64OffAddrAsWord64X2# = let x = x in x++-- | Reads vector; offset in scalar elements. ++indexWord8OffAddrAsWord8X32# :: Addr# -> Int# -> Word8X32#+indexWord8OffAddrAsWord8X32# = let x = x in x++-- | Reads vector; offset in scalar elements. ++indexWord16OffAddrAsWord16X16# :: Addr# -> Int# -> Word16X16#+indexWord16OffAddrAsWord16X16# = let x = x in x++-- | Reads vector; offset in scalar elements. ++indexWord32OffAddrAsWord32X8# :: Addr# -> Int# -> Word32X8#+indexWord32OffAddrAsWord32X8# = let x = x in x++-- | Reads vector; offset in scalar elements. ++indexWord64OffAddrAsWord64X4# :: Addr# -> Int# -> Word64X4#+indexWord64OffAddrAsWord64X4# = let x = x in x++-- | Reads vector; offset in scalar elements. ++indexWord8OffAddrAsWord8X64# :: Addr# -> Int# -> Word8X64#+indexWord8OffAddrAsWord8X64# = let x = x in x++-- | Reads vector; offset in scalar elements. ++indexWord16OffAddrAsWord16X32# :: Addr# -> Int# -> Word16X32#+indexWord16OffAddrAsWord16X32# = let x = x in x++-- | Reads vector; offset in scalar elements. ++indexWord32OffAddrAsWord32X16# :: Addr# -> Int# -> Word32X16#+indexWord32OffAddrAsWord32X16# = let x = x in x++-- | Reads vector; offset in scalar elements. ++indexWord64OffAddrAsWord64X8# :: Addr# -> Int# -> Word64X8#+indexWord64OffAddrAsWord64X8# = let x = x in x++-- | Reads vector; offset in scalar elements. ++indexFloatOffAddrAsFloatX4# :: Addr# -> Int# -> FloatX4#+indexFloatOffAddrAsFloatX4# = let x = x in x++-- | Reads vector; offset in scalar elements. ++indexDoubleOffAddrAsDoubleX2# :: Addr# -> Int# -> DoubleX2#+indexDoubleOffAddrAsDoubleX2# = let x = x in x++-- | Reads vector; offset in scalar elements. ++indexFloatOffAddrAsFloatX8# :: Addr# -> Int# -> FloatX8#+indexFloatOffAddrAsFloatX8# = let x = x in x++-- | Reads vector; offset in scalar elements. ++indexDoubleOffAddrAsDoubleX4# :: Addr# -> Int# -> DoubleX4#+indexDoubleOffAddrAsDoubleX4# = let x = x in x++-- | Reads vector; offset in scalar elements. ++indexFloatOffAddrAsFloatX16# :: Addr# -> Int# -> FloatX16#+indexFloatOffAddrAsFloatX16# = let x = x in x++-- | Reads vector; offset in scalar elements. ++indexDoubleOffAddrAsDoubleX8# :: Addr# -> Int# -> DoubleX8#+indexDoubleOffAddrAsDoubleX8# = let x = x in x++-- | Reads vector; offset in scalar elements. ++readInt8OffAddrAsInt8X16# :: Addr# -> Int# -> State# s -> (# State# s,Int8X16# #)+readInt8OffAddrAsInt8X16# = let x = x in x++-- | Reads vector; offset in scalar elements. ++readInt16OffAddrAsInt16X8# :: Addr# -> Int# -> State# s -> (# State# s,Int16X8# #)+readInt16OffAddrAsInt16X8# = let x = x in x++-- | Reads vector; offset in scalar elements. ++readInt32OffAddrAsInt32X4# :: Addr# -> Int# -> State# s -> (# State# s,Int32X4# #)+readInt32OffAddrAsInt32X4# = let x = x in x++-- | Reads vector; offset in scalar elements. ++readInt64OffAddrAsInt64X2# :: Addr# -> Int# -> State# s -> (# State# s,Int64X2# #)+readInt64OffAddrAsInt64X2# = let x = x in x++-- | Reads vector; offset in scalar elements. ++readInt8OffAddrAsInt8X32# :: Addr# -> Int# -> State# s -> (# State# s,Int8X32# #)+readInt8OffAddrAsInt8X32# = let x = x in x++-- | Reads vector; offset in scalar elements. ++readInt16OffAddrAsInt16X16# :: Addr# -> Int# -> State# s -> (# State# s,Int16X16# #)+readInt16OffAddrAsInt16X16# = let x = x in x++-- | Reads vector; offset in scalar elements. ++readInt32OffAddrAsInt32X8# :: Addr# -> Int# -> State# s -> (# State# s,Int32X8# #)+readInt32OffAddrAsInt32X8# = let x = x in x++-- | Reads vector; offset in scalar elements. ++readInt64OffAddrAsInt64X4# :: Addr# -> Int# -> State# s -> (# State# s,Int64X4# #)+readInt64OffAddrAsInt64X4# = let x = x in x++-- | Reads vector; offset in scalar elements. ++readInt8OffAddrAsInt8X64# :: Addr# -> Int# -> State# s -> (# State# s,Int8X64# #)+readInt8OffAddrAsInt8X64# = let x = x in x++-- | Reads vector; offset in scalar elements. ++readInt16OffAddrAsInt16X32# :: Addr# -> Int# -> State# s -> (# State# s,Int16X32# #)+readInt16OffAddrAsInt16X32# = let x = x in x++-- | Reads vector; offset in scalar elements. ++readInt32OffAddrAsInt32X16# :: Addr# -> Int# -> State# s -> (# State# s,Int32X16# #)+readInt32OffAddrAsInt32X16# = let x = x in x++-- | Reads vector; offset in scalar elements. ++readInt64OffAddrAsInt64X8# :: Addr# -> Int# -> State# s -> (# State# s,Int64X8# #)+readInt64OffAddrAsInt64X8# = let x = x in x++-- | Reads vector; offset in scalar elements. ++readWord8OffAddrAsWord8X16# :: Addr# -> Int# -> State# s -> (# State# s,Word8X16# #)+readWord8OffAddrAsWord8X16# = let x = x in x++-- | Reads vector; offset in scalar elements. ++readWord16OffAddrAsWord16X8# :: Addr# -> Int# -> State# s -> (# State# s,Word16X8# #)+readWord16OffAddrAsWord16X8# = let x = x in x++-- | Reads vector; offset in scalar elements. ++readWord32OffAddrAsWord32X4# :: Addr# -> Int# -> State# s -> (# State# s,Word32X4# #)+readWord32OffAddrAsWord32X4# = let x = x in x++-- | Reads vector; offset in scalar elements. ++readWord64OffAddrAsWord64X2# :: Addr# -> Int# -> State# s -> (# State# s,Word64X2# #)+readWord64OffAddrAsWord64X2# = let x = x in x++-- | Reads vector; offset in scalar elements. ++readWord8OffAddrAsWord8X32# :: Addr# -> Int# -> State# s -> (# State# s,Word8X32# #)+readWord8OffAddrAsWord8X32# = let x = x in x++-- | Reads vector; offset in scalar elements. ++readWord16OffAddrAsWord16X16# :: Addr# -> Int# -> State# s -> (# State# s,Word16X16# #)+readWord16OffAddrAsWord16X16# = let x = x in x++-- | Reads vector; offset in scalar elements. ++readWord32OffAddrAsWord32X8# :: Addr# -> Int# -> State# s -> (# State# s,Word32X8# #)+readWord32OffAddrAsWord32X8# = let x = x in x++-- | Reads vector; offset in scalar elements. ++readWord64OffAddrAsWord64X4# :: Addr# -> Int# -> State# s -> (# State# s,Word64X4# #)+readWord64OffAddrAsWord64X4# = let x = x in x++-- | Reads vector; offset in scalar elements. ++readWord8OffAddrAsWord8X64# :: Addr# -> Int# -> State# s -> (# State# s,Word8X64# #)+readWord8OffAddrAsWord8X64# = let x = x in x++-- | Reads vector; offset in scalar elements. ++readWord16OffAddrAsWord16X32# :: Addr# -> Int# -> State# s -> (# State# s,Word16X32# #)+readWord16OffAddrAsWord16X32# = let x = x in x++-- | Reads vector; offset in scalar elements. ++readWord32OffAddrAsWord32X16# :: Addr# -> Int# -> State# s -> (# State# s,Word32X16# #)+readWord32OffAddrAsWord32X16# = let x = x in x++-- | Reads vector; offset in scalar elements. ++readWord64OffAddrAsWord64X8# :: Addr# -> Int# -> State# s -> (# State# s,Word64X8# #)+readWord64OffAddrAsWord64X8# = let x = x in x++-- | Reads vector; offset in scalar elements. ++readFloatOffAddrAsFloatX4# :: Addr# -> Int# -> State# s -> (# State# s,FloatX4# #)+readFloatOffAddrAsFloatX4# = let x = x in x++-- | Reads vector; offset in scalar elements. ++readDoubleOffAddrAsDoubleX2# :: Addr# -> Int# -> State# s -> (# State# s,DoubleX2# #)+readDoubleOffAddrAsDoubleX2# = let x = x in x++-- | Reads vector; offset in scalar elements. ++readFloatOffAddrAsFloatX8# :: Addr# -> Int# -> State# s -> (# State# s,FloatX8# #)+readFloatOffAddrAsFloatX8# = let x = x in x++-- | Reads vector; offset in scalar elements. ++readDoubleOffAddrAsDoubleX4# :: Addr# -> Int# -> State# s -> (# State# s,DoubleX4# #)+readDoubleOffAddrAsDoubleX4# = let x = x in x++-- | Reads vector; offset in scalar elements. ++readFloatOffAddrAsFloatX16# :: Addr# -> Int# -> State# s -> (# State# s,FloatX16# #)+readFloatOffAddrAsFloatX16# = let x = x in x++-- | Reads vector; offset in scalar elements. ++readDoubleOffAddrAsDoubleX8# :: Addr# -> Int# -> State# s -> (# State# s,DoubleX8# #)+readDoubleOffAddrAsDoubleX8# = let x = x in x++-- | Write vector; offset in scalar elements. ++writeInt8OffAddrAsInt8X16# :: Addr# -> Int# -> Int8X16# -> State# s -> State# s+writeInt8OffAddrAsInt8X16# = let x = x in x++-- | Write vector; offset in scalar elements. ++writeInt16OffAddrAsInt16X8# :: Addr# -> Int# -> Int16X8# -> State# s -> State# s+writeInt16OffAddrAsInt16X8# = let x = x in x++-- | Write vector; offset in scalar elements. ++writeInt32OffAddrAsInt32X4# :: Addr# -> Int# -> Int32X4# -> State# s -> State# s+writeInt32OffAddrAsInt32X4# = let x = x in x++-- | Write vector; offset in scalar elements. ++writeInt64OffAddrAsInt64X2# :: Addr# -> Int# -> Int64X2# -> State# s -> State# s+writeInt64OffAddrAsInt64X2# = let x = x in x++-- | Write vector; offset in scalar elements. ++writeInt8OffAddrAsInt8X32# :: Addr# -> Int# -> Int8X32# -> State# s -> State# s+writeInt8OffAddrAsInt8X32# = let x = x in x++-- | Write vector; offset in scalar elements. ++writeInt16OffAddrAsInt16X16# :: Addr# -> Int# -> Int16X16# -> State# s -> State# s+writeInt16OffAddrAsInt16X16# = let x = x in x++-- | Write vector; offset in scalar elements. ++writeInt32OffAddrAsInt32X8# :: Addr# -> Int# -> Int32X8# -> State# s -> State# s+writeInt32OffAddrAsInt32X8# = let x = x in x++-- | Write vector; offset in scalar elements. ++writeInt64OffAddrAsInt64X4# :: Addr# -> Int# -> Int64X4# -> State# s -> State# s+writeInt64OffAddrAsInt64X4# = let x = x in x++-- | Write vector; offset in scalar elements. ++writeInt8OffAddrAsInt8X64# :: Addr# -> Int# -> Int8X64# -> State# s -> State# s+writeInt8OffAddrAsInt8X64# = let x = x in x++-- | Write vector; offset in scalar elements. ++writeInt16OffAddrAsInt16X32# :: Addr# -> Int# -> Int16X32# -> State# s -> State# s+writeInt16OffAddrAsInt16X32# = let x = x in x++-- | Write vector; offset in scalar elements. ++writeInt32OffAddrAsInt32X16# :: Addr# -> Int# -> Int32X16# -> State# s -> State# s+writeInt32OffAddrAsInt32X16# = let x = x in x++-- | Write vector; offset in scalar elements. ++writeInt64OffAddrAsInt64X8# :: Addr# -> Int# -> Int64X8# -> State# s -> State# s+writeInt64OffAddrAsInt64X8# = let x = x in x++-- | Write vector; offset in scalar elements. ++writeWord8OffAddrAsWord8X16# :: Addr# -> Int# -> Word8X16# -> State# s -> State# s+writeWord8OffAddrAsWord8X16# = let x = x in x++-- | Write vector; offset in scalar elements. ++writeWord16OffAddrAsWord16X8# :: Addr# -> Int# -> Word16X8# -> State# s -> State# s+writeWord16OffAddrAsWord16X8# = let x = x in x++-- | Write vector; offset in scalar elements. ++writeWord32OffAddrAsWord32X4# :: Addr# -> Int# -> Word32X4# -> State# s -> State# s+writeWord32OffAddrAsWord32X4# = let x = x in x++-- | Write vector; offset in scalar elements. ++writeWord64OffAddrAsWord64X2# :: Addr# -> Int# -> Word64X2# -> State# s -> State# s+writeWord64OffAddrAsWord64X2# = let x = x in x++-- | Write vector; offset in scalar elements. ++writeWord8OffAddrAsWord8X32# :: Addr# -> Int# -> Word8X32# -> State# s -> State# s+writeWord8OffAddrAsWord8X32# = let x = x in x++-- | Write vector; offset in scalar elements. ++writeWord16OffAddrAsWord16X16# :: Addr# -> Int# -> Word16X16# -> State# s -> State# s+writeWord16OffAddrAsWord16X16# = let x = x in x++-- | Write vector; offset in scalar elements. ++writeWord32OffAddrAsWord32X8# :: Addr# -> Int# -> Word32X8# -> State# s -> State# s+writeWord32OffAddrAsWord32X8# = let x = x in x++-- | Write vector; offset in scalar elements. ++writeWord64OffAddrAsWord64X4# :: Addr# -> Int# -> Word64X4# -> State# s -> State# s+writeWord64OffAddrAsWord64X4# = let x = x in x++-- | Write vector; offset in scalar elements. ++writeWord8OffAddrAsWord8X64# :: Addr# -> Int# -> Word8X64# -> State# s -> State# s+writeWord8OffAddrAsWord8X64# = let x = x in x++-- | Write vector; offset in scalar elements. ++writeWord16OffAddrAsWord16X32# :: Addr# -> Int# -> Word16X32# -> State# s -> State# s+writeWord16OffAddrAsWord16X32# = let x = x in x++-- | Write vector; offset in scalar elements. ++writeWord32OffAddrAsWord32X16# :: Addr# -> Int# -> Word32X16# -> State# s -> State# s+writeWord32OffAddrAsWord32X16# = let x = x in x++-- | Write vector; offset in scalar elements. ++writeWord64OffAddrAsWord64X8# :: Addr# -> Int# -> Word64X8# -> State# s -> State# s+writeWord64OffAddrAsWord64X8# = let x = x in x++-- | Write vector; offset in scalar elements. ++writeFloatOffAddrAsFloatX4# :: Addr# -> Int# -> FloatX4# -> State# s -> State# s+writeFloatOffAddrAsFloatX4# = let x = x in x++-- | Write vector; offset in scalar elements. ++writeDoubleOffAddrAsDoubleX2# :: Addr# -> Int# -> DoubleX2# -> State# s -> State# s+writeDoubleOffAddrAsDoubleX2# = let x = x in x++-- | Write vector; offset in scalar elements. ++writeFloatOffAddrAsFloatX8# :: Addr# -> Int# -> FloatX8# -> State# s -> State# s+writeFloatOffAddrAsFloatX8# = let x = x in x++-- | Write vector; offset in scalar elements. ++writeDoubleOffAddrAsDoubleX4# :: Addr# -> Int# -> DoubleX4# -> State# s -> State# s+writeDoubleOffAddrAsDoubleX4# = let x = x in x++-- | Write vector; offset in scalar elements. ++writeFloatOffAddrAsFloatX16# :: Addr# -> Int# -> FloatX16# -> State# s -> State# s+writeFloatOffAddrAsFloatX16# = let x = x in x++-- | Write vector; offset in scalar elements. ++writeDoubleOffAddrAsDoubleX8# :: Addr# -> Int# -> DoubleX8# -> State# s -> State# s+writeDoubleOffAddrAsDoubleX8# = let x = x in x++prefetchByteArray3# :: ByteArray# -> Int# -> State# s -> State# s+prefetchByteArray3# = let x = x in x++prefetchMutableByteArray3# :: MutableByteArray# s -> Int# -> State# s -> State# s+prefetchMutableByteArray3# = let x = x in x++prefetchAddr3# :: Addr# -> Int# -> State# s -> State# s+prefetchAddr3# = let x = x in x++prefetchValue3# :: a -> State# s -> State# s+prefetchValue3# = let x = x in x++prefetchByteArray2# :: ByteArray# -> Int# -> State# s -> State# s+prefetchByteArray2# = let x = x in x++prefetchMutableByteArray2# :: MutableByteArray# s -> Int# -> State# s -> State# s+prefetchMutableByteArray2# = let x = x in x++prefetchAddr2# :: Addr# -> Int# -> State# s -> State# s+prefetchAddr2# = let x = x in x++prefetchValue2# :: a -> State# s -> State# s+prefetchValue2# = let x = x in x++prefetchByteArray1# :: ByteArray# -> Int# -> State# s -> State# s+prefetchByteArray1# = let x = x in x++prefetchMutableByteArray1# :: MutableByteArray# s -> Int# -> State# s -> State# s+prefetchMutableByteArray1# = let x = x in x++prefetchAddr1# :: Addr# -> Int# -> State# s -> State# s+prefetchAddr1# = let x = x in x++prefetchValue1# :: a -> State# s -> State# s+prefetchValue1# = let x = x in x++prefetchByteArray0# :: ByteArray# -> Int# -> State# s -> State# s+prefetchByteArray0# = let x = x in x++prefetchMutableByteArray0# :: MutableByteArray# s -> Int# -> State# s -> State# s+prefetchMutableByteArray0# = let x = x in x++prefetchAddr0# :: Addr# -> Int# -> State# s -> State# s+prefetchAddr0# = let x = x in x++prefetchValue0# :: a -> State# s -> State# s+prefetchValue0# = let x = x in x
GHC/PrimopWrappers.hs view
@@ -2,7 +2,7 @@ module GHC.PrimopWrappers where import qualified GHC.Prim import GHC.Tuple ()-import GHC.Prim (Char#, Int#, Word#, Float#, Double#, State#, MutableArray#, Array#, MutableByteArray#, ByteArray#, Addr#, StablePtr#, MutableArrayArray#, ArrayArray#, MutVar#, RealWorld, TVar#, MVar#, ThreadId#, Weak#, StableName#, BCO#)+import GHC.Prim (Char#, Int#, Word#, Float#, Double#, State#, MutableArray#, Array#, SmallMutableArray#, SmallArray#, MutableByteArray#, ByteArray#, Addr#, StablePtr#, MutableArrayArray#, ArrayArray#, MutVar#, RealWorld, TVar#, MVar#, ThreadId#, Weak#, StableName#, BCO#) {-# NOINLINE gtChar# #-} gtChar# :: Char# -> Char# -> Int# gtChar# a1 a2 = (GHC.Prim.gtChar#) a1 a2@@ -192,6 +192,36 @@ {-# NOINLINE popCnt# #-} popCnt# :: Word# -> Word# popCnt# a1 = (GHC.Prim.popCnt#) a1+{-# NOINLINE clz8# #-}+clz8# :: Word# -> Word#+clz8# a1 = (GHC.Prim.clz8#) a1+{-# NOINLINE clz16# #-}+clz16# :: Word# -> Word#+clz16# a1 = (GHC.Prim.clz16#) a1+{-# NOINLINE clz32# #-}+clz32# :: Word# -> Word#+clz32# a1 = (GHC.Prim.clz32#) a1+{-# NOINLINE clz64# #-}+clz64# :: Word# -> Word#+clz64# a1 = (GHC.Prim.clz64#) a1+{-# NOINLINE clz# #-}+clz# :: Word# -> Word#+clz# a1 = (GHC.Prim.clz#) a1+{-# NOINLINE ctz8# #-}+ctz8# :: Word# -> Word#+ctz8# a1 = (GHC.Prim.ctz8#) a1+{-# NOINLINE ctz16# #-}+ctz16# :: Word# -> Word#+ctz16# a1 = (GHC.Prim.ctz16#) a1+{-# NOINLINE ctz32# #-}+ctz32# :: Word# -> Word#+ctz32# a1 = (GHC.Prim.ctz32#) a1+{-# NOINLINE ctz64# #-}+ctz64# :: Word# -> Word#+ctz64# a1 = (GHC.Prim.ctz64#) a1+{-# NOINLINE ctz# #-}+ctz# :: Word# -> Word#+ctz# a1 = (GHC.Prim.ctz#) a1 {-# NOINLINE byteSwap16# #-} byteSwap16# :: Word# -> Word# byteSwap16# a1 = (GHC.Prim.byteSwap16#) a1@@ -303,6 +333,9 @@ {-# NOINLINE decodeDouble_2Int# #-} decodeDouble_2Int# :: Double# -> (# Int#,Word#,Word#,Int# #) decodeDouble_2Int# a1 = (GHC.Prim.decodeDouble_2Int#) a1+{-# NOINLINE decodeDouble_Int64# #-}+decodeDouble_Int64# :: Double# -> (# Int#,Int# #)+decodeDouble_Int64# a1 = (GHC.Prim.decodeDouble_Int64#) a1 {-# NOINLINE gtFloat# #-} gtFloat# :: Float# -> Float# -> Int# gtFloat# a1 a2 = (GHC.Prim.gtFloat#) a1 a2@@ -432,6 +465,54 @@ {-# NOINLINE casArray# #-} casArray# :: MutableArray# s a -> Int# -> a -> a -> State# s -> (# State# s,Int#,a #) casArray# a1 a2 a3 a4 a5 = (GHC.Prim.casArray#) a1 a2 a3 a4 a5+{-# NOINLINE newSmallArray# #-}+newSmallArray# :: Int# -> a -> State# s -> (# State# s,SmallMutableArray# s a #)+newSmallArray# a1 a2 a3 = (GHC.Prim.newSmallArray#) a1 a2 a3+{-# NOINLINE sameSmallMutableArray# #-}+sameSmallMutableArray# :: SmallMutableArray# s a -> SmallMutableArray# s a -> Int#+sameSmallMutableArray# a1 a2 = (GHC.Prim.sameSmallMutableArray#) a1 a2+{-# NOINLINE readSmallArray# #-}+readSmallArray# :: SmallMutableArray# s a -> Int# -> State# s -> (# State# s,a #)+readSmallArray# a1 a2 a3 = (GHC.Prim.readSmallArray#) a1 a2 a3+{-# NOINLINE writeSmallArray# #-}+writeSmallArray# :: SmallMutableArray# s a -> Int# -> a -> State# s -> State# s+writeSmallArray# a1 a2 a3 a4 = (GHC.Prim.writeSmallArray#) a1 a2 a3 a4+{-# NOINLINE sizeofSmallArray# #-}+sizeofSmallArray# :: SmallArray# a -> Int#+sizeofSmallArray# a1 = (GHC.Prim.sizeofSmallArray#) a1+{-# NOINLINE sizeofSmallMutableArray# #-}+sizeofSmallMutableArray# :: SmallMutableArray# s a -> Int#+sizeofSmallMutableArray# a1 = (GHC.Prim.sizeofSmallMutableArray#) a1+{-# NOINLINE indexSmallArray# #-}+indexSmallArray# :: SmallArray# a -> Int# -> (# a #)+indexSmallArray# a1 a2 = (GHC.Prim.indexSmallArray#) a1 a2+{-# NOINLINE unsafeFreezeSmallArray# #-}+unsafeFreezeSmallArray# :: SmallMutableArray# s a -> State# s -> (# State# s,SmallArray# a #)+unsafeFreezeSmallArray# a1 a2 = (GHC.Prim.unsafeFreezeSmallArray#) a1 a2+{-# NOINLINE unsafeThawSmallArray# #-}+unsafeThawSmallArray# :: SmallArray# a -> State# s -> (# State# s,SmallMutableArray# s a #)+unsafeThawSmallArray# a1 a2 = (GHC.Prim.unsafeThawSmallArray#) a1 a2+{-# NOINLINE copySmallArray# #-}+copySmallArray# :: SmallArray# a -> Int# -> SmallMutableArray# s a -> Int# -> Int# -> State# s -> State# s+copySmallArray# a1 a2 a3 a4 a5 a6 = (GHC.Prim.copySmallArray#) a1 a2 a3 a4 a5 a6+{-# NOINLINE copySmallMutableArray# #-}+copySmallMutableArray# :: SmallMutableArray# s a -> Int# -> SmallMutableArray# s a -> Int# -> Int# -> State# s -> State# s+copySmallMutableArray# a1 a2 a3 a4 a5 a6 = (GHC.Prim.copySmallMutableArray#) a1 a2 a3 a4 a5 a6+{-# NOINLINE cloneSmallArray# #-}+cloneSmallArray# :: SmallArray# a -> Int# -> Int# -> SmallArray# a+cloneSmallArray# a1 a2 a3 = (GHC.Prim.cloneSmallArray#) a1 a2 a3+{-# NOINLINE cloneSmallMutableArray# #-}+cloneSmallMutableArray# :: SmallMutableArray# s a -> Int# -> Int# -> State# s -> (# State# s,SmallMutableArray# s a #)+cloneSmallMutableArray# a1 a2 a3 a4 = (GHC.Prim.cloneSmallMutableArray#) a1 a2 a3 a4+{-# NOINLINE freezeSmallArray# #-}+freezeSmallArray# :: SmallMutableArray# s a -> Int# -> Int# -> State# s -> (# State# s,SmallArray# a #)+freezeSmallArray# a1 a2 a3 a4 = (GHC.Prim.freezeSmallArray#) a1 a2 a3 a4+{-# NOINLINE thawSmallArray# #-}+thawSmallArray# :: SmallArray# a -> Int# -> Int# -> State# s -> (# State# s,SmallMutableArray# s a #)+thawSmallArray# a1 a2 a3 a4 = (GHC.Prim.thawSmallArray#) a1 a2 a3 a4+{-# NOINLINE casSmallArray# #-}+casSmallArray# :: SmallMutableArray# s a -> Int# -> a -> a -> State# s -> (# State# s,Int#,a #)+casSmallArray# a1 a2 a3 a4 a5 = (GHC.Prim.casSmallArray#) a1 a2 a3 a4 a5 {-# NOINLINE newByteArray# #-} newByteArray# :: Int# -> State# s -> (# State# s,MutableByteArray# s #) newByteArray# a1 a2 = (GHC.Prim.newByteArray#) a1 a2@@ -447,6 +528,12 @@ {-# NOINLINE sameMutableByteArray# #-} sameMutableByteArray# :: MutableByteArray# s -> MutableByteArray# s -> Int# sameMutableByteArray# a1 a2 = (GHC.Prim.sameMutableByteArray#) a1 a2+{-# NOINLINE shrinkMutableByteArray# #-}+shrinkMutableByteArray# :: MutableByteArray# s -> Int# -> State# s -> State# s+shrinkMutableByteArray# a1 a2 a3 = (GHC.Prim.shrinkMutableByteArray#) a1 a2 a3+{-# NOINLINE resizeMutableByteArray# #-}+resizeMutableByteArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,MutableByteArray# s #)+resizeMutableByteArray# a1 a2 a3 = (GHC.Prim.resizeMutableByteArray#) a1 a2 a3 {-# NOINLINE unsafeFreezeByteArray# #-} unsafeFreezeByteArray# :: MutableByteArray# s -> State# s -> (# State# s,ByteArray# #) unsafeFreezeByteArray# a1 a2 = (GHC.Prim.unsafeFreezeByteArray#) a1 a2@@ -618,12 +705,33 @@ {-# NOINLINE setByteArray# #-} setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Int# -> State# s -> State# s setByteArray# a1 a2 a3 a4 a5 = (GHC.Prim.setByteArray#) a1 a2 a3 a4 a5+{-# NOINLINE atomicReadIntArray# #-}+atomicReadIntArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s,Int# #)+atomicReadIntArray# a1 a2 a3 = (GHC.Prim.atomicReadIntArray#) a1 a2 a3+{-# NOINLINE atomicWriteIntArray# #-}+atomicWriteIntArray# :: MutableByteArray# s -> Int# -> Int# -> State# s -> State# s+atomicWriteIntArray# a1 a2 a3 a4 = (GHC.Prim.atomicWriteIntArray#) a1 a2 a3 a4 {-# NOINLINE casIntArray# #-} casIntArray# :: MutableByteArray# s -> Int# -> Int# -> Int# -> State# s -> (# State# s,Int# #) casIntArray# a1 a2 a3 a4 a5 = (GHC.Prim.casIntArray#) a1 a2 a3 a4 a5 {-# NOINLINE fetchAddIntArray# #-} fetchAddIntArray# :: MutableByteArray# s -> Int# -> Int# -> State# s -> (# State# s,Int# #) fetchAddIntArray# a1 a2 a3 a4 = (GHC.Prim.fetchAddIntArray#) a1 a2 a3 a4+{-# NOINLINE fetchSubIntArray# #-}+fetchSubIntArray# :: MutableByteArray# s -> Int# -> Int# -> State# s -> (# State# s,Int# #)+fetchSubIntArray# a1 a2 a3 a4 = (GHC.Prim.fetchSubIntArray#) a1 a2 a3 a4+{-# NOINLINE fetchAndIntArray# #-}+fetchAndIntArray# :: MutableByteArray# s -> Int# -> Int# -> State# s -> (# State# s,Int# #)+fetchAndIntArray# a1 a2 a3 a4 = (GHC.Prim.fetchAndIntArray#) a1 a2 a3 a4+{-# NOINLINE fetchNandIntArray# #-}+fetchNandIntArray# :: MutableByteArray# s -> Int# -> Int# -> State# s -> (# State# s,Int# #)+fetchNandIntArray# a1 a2 a3 a4 = (GHC.Prim.fetchNandIntArray#) a1 a2 a3 a4+{-# NOINLINE fetchOrIntArray# #-}+fetchOrIntArray# :: MutableByteArray# s -> Int# -> Int# -> State# s -> (# State# s,Int# #)+fetchOrIntArray# a1 a2 a3 a4 = (GHC.Prim.fetchOrIntArray#) a1 a2 a3 a4+{-# NOINLINE fetchXorIntArray# #-}+fetchXorIntArray# :: MutableByteArray# s -> Int# -> Int# -> State# s -> (# State# s,Int# #)+fetchXorIntArray# a1 a2 a3 a4 = (GHC.Prim.fetchXorIntArray#) a1 a2 a3 a4 {-# NOINLINE newArrayArray# #-} newArrayArray# :: Int# -> State# s -> (# State# s,MutableArrayArray# s #) newArrayArray# a1 a2 = (GHC.Prim.newArrayArray#) a1 a2@@ -1063,38 +1171,50 @@ traceMarker# :: Addr# -> State# s -> State# s traceMarker# a1 a2 = (GHC.Prim.traceMarker#) a1 a2 {-# NOINLINE prefetchByteArray3# #-}-prefetchByteArray3# :: ByteArray# -> Int# -> ByteArray#-prefetchByteArray3# a1 a2 = (GHC.Prim.prefetchByteArray3#) a1 a2+prefetchByteArray3# :: ByteArray# -> Int# -> State# s -> State# s+prefetchByteArray3# a1 a2 a3 = (GHC.Prim.prefetchByteArray3#) a1 a2 a3 {-# NOINLINE prefetchMutableByteArray3# #-} prefetchMutableByteArray3# :: MutableByteArray# s -> Int# -> State# s -> State# s prefetchMutableByteArray3# a1 a2 a3 = (GHC.Prim.prefetchMutableByteArray3#) a1 a2 a3 {-# NOINLINE prefetchAddr3# #-}-prefetchAddr3# :: Addr# -> Int# -> Addr#-prefetchAddr3# a1 a2 = (GHC.Prim.prefetchAddr3#) a1 a2+prefetchAddr3# :: Addr# -> Int# -> State# s -> State# s+prefetchAddr3# a1 a2 a3 = (GHC.Prim.prefetchAddr3#) a1 a2 a3+{-# NOINLINE prefetchValue3# #-}+prefetchValue3# :: a -> State# s -> State# s+prefetchValue3# a1 a2 = (GHC.Prim.prefetchValue3#) a1 a2 {-# NOINLINE prefetchByteArray2# #-}-prefetchByteArray2# :: ByteArray# -> Int# -> ByteArray#-prefetchByteArray2# a1 a2 = (GHC.Prim.prefetchByteArray2#) a1 a2+prefetchByteArray2# :: ByteArray# -> Int# -> State# s -> State# s+prefetchByteArray2# a1 a2 a3 = (GHC.Prim.prefetchByteArray2#) a1 a2 a3 {-# NOINLINE prefetchMutableByteArray2# #-} prefetchMutableByteArray2# :: MutableByteArray# s -> Int# -> State# s -> State# s prefetchMutableByteArray2# a1 a2 a3 = (GHC.Prim.prefetchMutableByteArray2#) a1 a2 a3 {-# NOINLINE prefetchAddr2# #-}-prefetchAddr2# :: Addr# -> Int# -> Addr#-prefetchAddr2# a1 a2 = (GHC.Prim.prefetchAddr2#) a1 a2+prefetchAddr2# :: Addr# -> Int# -> State# s -> State# s+prefetchAddr2# a1 a2 a3 = (GHC.Prim.prefetchAddr2#) a1 a2 a3+{-# NOINLINE prefetchValue2# #-}+prefetchValue2# :: a -> State# s -> State# s+prefetchValue2# a1 a2 = (GHC.Prim.prefetchValue2#) a1 a2 {-# NOINLINE prefetchByteArray1# #-}-prefetchByteArray1# :: ByteArray# -> Int# -> ByteArray#-prefetchByteArray1# a1 a2 = (GHC.Prim.prefetchByteArray1#) a1 a2+prefetchByteArray1# :: ByteArray# -> Int# -> State# s -> State# s+prefetchByteArray1# a1 a2 a3 = (GHC.Prim.prefetchByteArray1#) a1 a2 a3 {-# NOINLINE prefetchMutableByteArray1# #-} prefetchMutableByteArray1# :: MutableByteArray# s -> Int# -> State# s -> State# s prefetchMutableByteArray1# a1 a2 a3 = (GHC.Prim.prefetchMutableByteArray1#) a1 a2 a3 {-# NOINLINE prefetchAddr1# #-}-prefetchAddr1# :: Addr# -> Int# -> Addr#-prefetchAddr1# a1 a2 = (GHC.Prim.prefetchAddr1#) a1 a2+prefetchAddr1# :: Addr# -> Int# -> State# s -> State# s+prefetchAddr1# a1 a2 a3 = (GHC.Prim.prefetchAddr1#) a1 a2 a3+{-# NOINLINE prefetchValue1# #-}+prefetchValue1# :: a -> State# s -> State# s+prefetchValue1# a1 a2 = (GHC.Prim.prefetchValue1#) a1 a2 {-# NOINLINE prefetchByteArray0# #-}-prefetchByteArray0# :: ByteArray# -> Int# -> ByteArray#-prefetchByteArray0# a1 a2 = (GHC.Prim.prefetchByteArray0#) a1 a2+prefetchByteArray0# :: ByteArray# -> Int# -> State# s -> State# s+prefetchByteArray0# a1 a2 a3 = (GHC.Prim.prefetchByteArray0#) a1 a2 a3 {-# NOINLINE prefetchMutableByteArray0# #-} prefetchMutableByteArray0# :: MutableByteArray# s -> Int# -> State# s -> State# s prefetchMutableByteArray0# a1 a2 a3 = (GHC.Prim.prefetchMutableByteArray0#) a1 a2 a3 {-# NOINLINE prefetchAddr0# #-}-prefetchAddr0# :: Addr# -> Int# -> Addr#-prefetchAddr0# a1 a2 = (GHC.Prim.prefetchAddr0#) a1 a2+prefetchAddr0# :: Addr# -> Int# -> State# s -> State# s+prefetchAddr0# a1 a2 a3 = (GHC.Prim.prefetchAddr0#) a1 a2 a3+{-# NOINLINE prefetchValue0# #-}+prefetchValue0# :: a -> State# s -> State# s+prefetchValue0# a1 a2 = (GHC.Prim.prefetchValue0#) a1 a2
GHC/Types.hs view
@@ -1,4 +1,5 @@-{-# LANGUAGE MagicHash, NoImplicitPrelude, TypeFamilies, UnboxedTuples #-}+{-# LANGUAGE MagicHash, NoImplicitPrelude, TypeFamilies, UnboxedTuples,+ RoleAnnotations #-} ----------------------------------------------------------------------------- -- | -- Module : GHC.Types@@ -20,7 +21,8 @@ Float(..), Double(..), Ordering(..), IO(..), isTrue#,- SPEC(..)+ SPEC(..),+ Coercible, ) where import GHC.Prim@@ -79,8 +81,31 @@ or the '>>' and '>>=' operations from the 'Monad' class. -} newtype IO a = IO (State# RealWorld -> (# State# RealWorld, a #))+type role IO representational+{-+The above role annotation is redundant but is included because this role+is significant in the normalisation of FFI types. Specifically, if this+role were to become nominal (which would be very strange, indeed!), changes+elsewhere in GHC would be necessary. See [FFI type roles] in TcForeign.+-} +{-+Note [Kind-changing of (~) and Coercible]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +(~) and Coercible are tricky to define. To the user, they must appear as+constraints, but we cannot define them as such in Haskell. But we also cannot+just define them only in GHC.Prim (like (->)), because we need a real module+for them, e.g. to compile the constructor's info table.++Furthermore the type of MkCoercible cannot be written in Haskell+(no syntax for ~#R).++So we define them as regular data types in GHC.Types, and do magic in TysWiredIn,+inside GHC, to change the kind and type.+-}++ -- | A data constructor used to box up all unlifted equalities -- -- The type constructor is special in that GHC pretends that it@@ -88,9 +113,6 @@ data (~) a b = Eq# ((~#) a b) --- Despite this not being exported here, the documentation will--- be used by haddock, hence the user-facing blurb here, and not in primops.txt.pp:- -- | This two-parameter class has instances for types @a@ and @b@ if -- the compiler can infer that they have the same representation. This class -- does not have regular instances; instead they are created on-the-fly during@@ -137,10 +159,15 @@ -- <http://www.cis.upenn.edu/~eir/papers/2014/coercible/coercible.pdf Safe Coercions> -- by Joachim Breitner, Richard A. Eisenberg, Simon Peyton Jones and Stephanie Weirich. ----- /Since: 4.7.0.0/+-- @since 4.7.0.0 data Coercible a b = MkCoercible ((~#) a b)+-- It's really ~R# (representational equality), not ~#,+-- but * we don't yet have syntax for ~R#,+-- * the compiled code is the same either way+-- * TysWiredIn has the truthful types+-- Also see Note [Kind-changing of (~) and Coercible] --- | Alias for tagToEnum#. Returns True of its parameter is 1# and False+-- | Alias for 'tagToEnum#'. Returns True if its parameter is 1# and False -- if it is 0#. {-# INLINE isTrue# #-}@@ -202,7 +229,7 @@ -- you're reading this in 2023 then things went wrong). See #8326. -- --- | SPEC is used by GHC in the @SpecConstr@ pass in order to inform+-- | 'SPEC' is used by GHC in the @SpecConstr@ pass in order to inform -- the compiler when to be particularly aggressive. In particular, it -- tells GHC to specialize regardless of size or the number of -- specializations. However, not all loops fall into this category.
+ cbits/atomic.c view
@@ -0,0 +1,320 @@+#include "Rts.h"++// Fallbacks for atomic primops on byte arrays. The builtins used+// below are supported on both GCC and LLVM.+//+// Ideally these function would take StgWord8, StgWord16, etc but+// older GCC versions incorrectly assume that the register that the+// argument is passed in has been zero extended, which is incorrect+// according to the ABI and is not what GHC does when it generates+// calls to these functions.++// FetchAddByteArrayOp_Int++extern StgWord hs_atomic_add8(volatile StgWord8 *x, StgWord val);+StgWord+hs_atomic_add8(volatile StgWord8 *x, StgWord val)+{+ return __sync_fetch_and_add(x, (StgWord8) val);+}++extern StgWord hs_atomic_add16(volatile StgWord16 *x, StgWord val);+StgWord+hs_atomic_add16(volatile StgWord16 *x, StgWord val)+{+ return __sync_fetch_and_add(x, (StgWord16) val);+}++extern StgWord hs_atomic_add32(volatile StgWord32 *x, StgWord val);+StgWord+hs_atomic_add32(volatile StgWord32 *x, StgWord val)+{+ return __sync_fetch_and_add(x, (StgWord32) val);+}++#if WORD_SIZE_IN_BITS == 64+extern StgWord64 hs_atomic_add64(volatile StgWord64 *x, StgWord64 val);+StgWord64+hs_atomic_add64(volatile StgWord64 *x, StgWord64 val)+{+ return __sync_fetch_and_add(x, val);+}+#endif++// FetchSubByteArrayOp_Int++extern StgWord hs_atomic_sub8(volatile StgWord8 *x, StgWord val);+StgWord+hs_atomic_sub8(volatile StgWord8 *x, StgWord val)+{+ return __sync_fetch_and_sub(x, (StgWord8) val);+}++extern StgWord hs_atomic_sub16(volatile StgWord16 *x, StgWord val);+StgWord+hs_atomic_sub16(volatile StgWord16 *x, StgWord val)+{+ return __sync_fetch_and_sub(x, (StgWord16) val);+}++extern StgWord hs_atomic_sub32(volatile StgWord32 *x, StgWord val);+StgWord+hs_atomic_sub32(volatile StgWord32 *x, StgWord val)+{+ return __sync_fetch_and_sub(x, (StgWord32) val);+}++#if WORD_SIZE_IN_BITS == 64+extern StgWord64 hs_atomic_sub64(volatile StgWord64 *x, StgWord64 val);+StgWord64+hs_atomic_sub64(volatile StgWord64 *x, StgWord64 val)+{+ return __sync_fetch_and_sub(x, val);+}+#endif++// FetchAndByteArrayOp_Int++extern StgWord hs_atomic_and8(volatile StgWord8 *x, StgWord val);+StgWord+hs_atomic_and8(volatile StgWord8 *x, StgWord val)+{+ return __sync_fetch_and_and(x, (StgWord8) val);+}++extern StgWord hs_atomic_and16(volatile StgWord16 *x, StgWord val);+StgWord+hs_atomic_and16(volatile StgWord16 *x, StgWord val)+{+ return __sync_fetch_and_and(x, (StgWord16) val);+}++extern StgWord hs_atomic_and32(volatile StgWord32 *x, StgWord val);+StgWord+hs_atomic_and32(volatile StgWord32 *x, StgWord val)+{+ return __sync_fetch_and_and(x, (StgWord32) val);+}++#if WORD_SIZE_IN_BITS == 64+extern StgWord64 hs_atomic_and64(volatile StgWord64 *x, StgWord64 val);+StgWord64+hs_atomic_and64(volatile StgWord64 *x, StgWord64 val)+{+ return __sync_fetch_and_and(x, val);+}+#endif++// FetchNandByteArrayOp_Int++// Workaround for http://llvm.org/bugs/show_bug.cgi?id=8842+#define CAS_NAND(x, val) \+ { \+ __typeof__ (*(x)) tmp = *(x); \+ while (!__sync_bool_compare_and_swap(x, tmp, ~(tmp & (val)))) { \+ tmp = *(x); \+ } \+ return tmp; \+ }++extern StgWord hs_atomic_nand8(volatile StgWord8 *x, StgWord val);+StgWord+hs_atomic_nand8(volatile StgWord8 *x, StgWord val)+{+#ifdef __clang__+ CAS_NAND(x, (StgWord8) val)+#else+ return __sync_fetch_and_nand(x, (StgWord8) val);+#endif+}++extern StgWord hs_atomic_nand16(volatile StgWord16 *x, StgWord val);+StgWord+hs_atomic_nand16(volatile StgWord16 *x, StgWord val)+{+#ifdef __clang__+ CAS_NAND(x, (StgWord16) val);+#else+ return __sync_fetch_and_nand(x, (StgWord16) val);+#endif+}++extern StgWord hs_atomic_nand32(volatile StgWord32 *x, StgWord val);+StgWord+hs_atomic_nand32(volatile StgWord32 *x, StgWord val)+{+#ifdef __clang__+ CAS_NAND(x, (StgWord32) val);+#else+ return __sync_fetch_and_nand(x, (StgWord32) val);+#endif+}++#if WORD_SIZE_IN_BITS == 64+extern StgWord64 hs_atomic_nand64(volatile StgWord64 *x, StgWord64 val);+StgWord64+hs_atomic_nand64(volatile StgWord64 *x, StgWord64 val)+{+#ifdef __clang__+ CAS_NAND(x, val);+#else+ return __sync_fetch_and_nand(x, val);+#endif+}+#endif++// FetchOrByteArrayOp_Int++extern StgWord hs_atomic_or8(volatile StgWord8 *x, StgWord val);+StgWord+hs_atomic_or8(volatile StgWord8 *x, StgWord val)+{+ return __sync_fetch_and_or(x, (StgWord8) val);+}++extern StgWord hs_atomic_or16(volatile StgWord16 *x, StgWord val);+StgWord+hs_atomic_or16(volatile StgWord16 *x, StgWord val)+{+ return __sync_fetch_and_or(x, (StgWord16) val);+}++extern StgWord hs_atomic_or32(volatile StgWord32 *x, StgWord val);+StgWord+hs_atomic_or32(volatile StgWord32 *x, StgWord val)+{+ return __sync_fetch_and_or(x, (StgWord32) val);+}++#if WORD_SIZE_IN_BITS == 64+extern StgWord64 hs_atomic_or64(volatile StgWord64 *x, StgWord64 val);+StgWord64+hs_atomic_or64(volatile StgWord64 *x, StgWord64 val)+{+ return __sync_fetch_and_or(x, val);+}+#endif++// FetchXorByteArrayOp_Int++extern StgWord hs_atomic_xor8(volatile StgWord8 *x, StgWord val);+StgWord+hs_atomic_xor8(volatile StgWord8 *x, StgWord val)+{+ return __sync_fetch_and_xor(x, (StgWord8) val);+}++extern StgWord hs_atomic_xor16(volatile StgWord16 *x, StgWord val);+StgWord+hs_atomic_xor16(volatile StgWord16 *x, StgWord val)+{+ return __sync_fetch_and_xor(x, (StgWord16) val);+}++extern StgWord hs_atomic_xor32(volatile StgWord32 *x, StgWord val);+StgWord+hs_atomic_xor32(volatile StgWord32 *x, StgWord val)+{+ return __sync_fetch_and_xor(x, (StgWord32) val);+}++#if WORD_SIZE_IN_BITS == 64+extern StgWord64 hs_atomic_xor64(volatile StgWord64 *x, StgWord64 val);+StgWord64+hs_atomic_xor64(volatile StgWord64 *x, StgWord64 val)+{+ return __sync_fetch_and_xor(x, val);+}+#endif++// CasByteArrayOp_Int++extern StgWord hs_cmpxchg8(volatile StgWord8 *x, StgWord old, StgWord new);+StgWord+hs_cmpxchg8(volatile StgWord8 *x, StgWord old, StgWord new)+{+ return __sync_val_compare_and_swap(x, (StgWord8) old, (StgWord8) new);+}++extern StgWord hs_cmpxchg16(volatile StgWord16 *x, StgWord old, StgWord new);+StgWord+hs_cmpxchg16(volatile StgWord16 *x, StgWord old, StgWord new)+{+ return __sync_val_compare_and_swap(x, (StgWord16) old, (StgWord16) new);+}++extern StgWord hs_cmpxchg32(volatile StgWord32 *x, StgWord old, StgWord new);+StgWord+hs_cmpxchg32(volatile StgWord32 *x, StgWord old, StgWord new)+{+ return __sync_val_compare_and_swap(x, (StgWord32) old, (StgWord32) new);+}++#if WORD_SIZE_IN_BITS == 64+extern StgWord hs_cmpxchg64(volatile StgWord64 *x, StgWord64 old, StgWord64 new);+StgWord+hs_cmpxchg64(volatile StgWord64 *x, StgWord64 old, StgWord64 new)+{+ return __sync_val_compare_and_swap(x, old, new);+}+#endif++// AtomicReadByteArrayOp_Int++extern StgWord hs_atomicread8(volatile StgWord8 *x);+StgWord+hs_atomicread8(volatile StgWord8 *x)+{+ return *x;+}++extern StgWord hs_atomicread16(volatile StgWord16 *x);+StgWord+hs_atomicread16(volatile StgWord16 *x)+{+ return *x;+}++extern StgWord hs_atomicread32(volatile StgWord32 *x);+StgWord+hs_atomicread32(volatile StgWord32 *x)+{+ return *x;+}++extern StgWord64 hs_atomicread64(volatile StgWord64 *x);+StgWord64+hs_atomicread64(volatile StgWord64 *x)+{+ return *x;+}++// AtomicWriteByteArrayOp_Int++extern void hs_atomicwrite8(volatile StgWord8 *x, StgWord val);+void+hs_atomicwrite8(volatile StgWord8 *x, StgWord val)+{+ *x = (StgWord8) val;+}++extern void hs_atomicwrite16(volatile StgWord16 *x, StgWord val);+void+hs_atomicwrite16(volatile StgWord16 *x, StgWord val)+{+ *x = (StgWord16) val;+}++extern void hs_atomicwrite32(volatile StgWord32 *x, StgWord val);+void+hs_atomicwrite32(volatile StgWord32 *x, StgWord val)+{+ *x = (StgWord32) val;+}++extern void hs_atomicwrite64(volatile StgWord64 *x, StgWord64 val);+void+hs_atomicwrite64(volatile StgWord64 *x, StgWord64 val)+{+ *x = (StgWord64) val;+}
+ cbits/clz.c view
@@ -0,0 +1,41 @@+#include "MachDeps.h"+#include "Rts.h"+#include <stdint.h>++// Fall-back implementations for count-leading-zeros primop+//+// __builtin_clz*() is supported by GCC and Clang++#if SIZEOF_UNSIGNED_INT == 4+StgWord+hs_clz8(StgWord x)+{+ return (uint8_t)x ? __builtin_clz((uint8_t)x)-24 : 8;+}++StgWord+hs_clz16(StgWord x)+{+ return (uint16_t)x ? __builtin_clz((uint16_t)x)-16 : 16;+}++StgWord+hs_clz32(StgWord x)+{+ return (uint32_t)x ? __builtin_clz((uint32_t)x) : 32;+}+#else+# error no suitable __builtin_clz() found+#endif++StgWord+hs_clz64(StgWord64 x)+{+#if SIZEOF_UNSIGNED_LONG == 8+ return x ? __builtin_clzl(x) : 64;+#elif SIZEOF_UNSIGNED_LONG_LONG == 8+ return x ? __builtin_clzll(x) : 64;+#else+# error no suitable __builtin_clz() found+#endif+}
+ cbits/ctz.c view
@@ -0,0 +1,57 @@+#include "MachDeps.h"+#include "Rts.h"+#include <stdint.h>++// Fall-back implementations for count-trailing-zeros primop+//+// __builtin_ctz*() is supported by GCC and Clang++#if SIZEOF_UNSIGNED_INT == 4+StgWord+hs_ctz8(StgWord x)+{+ return (uint8_t)x ? __builtin_ctz(x) : 8;+}++StgWord+hs_ctz16(StgWord x)+{+ return (uint16_t)x ? __builtin_ctz(x) : 16;+}++StgWord+hs_ctz32(StgWord x)+{+ return (uint32_t)x ? __builtin_ctz(x) : 32;+}+#else+# error no suitable __builtin_ctz() found+#endif++StgWord+hs_ctz64(StgWord64 x)+{+#if defined(__GNUC__) && defined(i386_HOST_ARCH)+ /* On Linux/i386, the 64bit `__builtin_ctzll()` instrinsic doesn't+ get inlined by GCC but rather a short `__ctzdi2` runtime function+ is inserted when needed into compiled object files.++ This workaround forces GCC on 32bit x86 to to express `hs_ctz64` in+ terms of the 32bit `__builtin_ctz()` (this is no loss, as there's no+ 64bit BSF instruction on i686 anyway) and thus avoid the problematic+ out-of-line runtime function.+ */++ if (!x) return 64;++ return ((uint32_t)x ? __builtin_ctz((uint32_t)x)+ : (__builtin_ctz(x >> 32) + 32));++#elif SIZEOF_UNSIGNED_LONG == 8+ return x ? __builtin_ctzl(x) : 64;+#elif SIZEOF_UNSIGNED_LONG_LONG == 8+ return x ? __builtin_ctzll(x) : 64;+#else+# error no suitable __builtin_ctz() found+#endif+}
cbits/popcnt.c view
@@ -1,4 +1,5 @@ #include "Rts.h"+#include "MachDeps.h" static const unsigned char popcount_tab[] = {@@ -51,7 +52,7 @@ popcount_tab[(unsigned char)(x >> 56)]; } -#ifdef i386_HOST_ARCH+#if WORD_SIZE_IN_BITS == 32 extern StgWord hs_popcnt(StgWord x); StgWord@@ -63,7 +64,7 @@ popcount_tab[(unsigned char)(x >> 24)]; } -#else+#elif WORD_SIZE_IN_BITS == 64 extern StgWord hs_popcnt(StgWord x); StgWord@@ -78,5 +79,9 @@ popcount_tab[(unsigned char)(x >> 48)] + popcount_tab[(unsigned char)(x >> 56)]; }++#else++#error Unknown machine word size #endif
ghc-prim.cabal view
@@ -1,6 +1,6 @@ name: ghc-prim-version: 0.3.1.0--- GHC 7.6.1 released with 0.3.0.0+version: 0.4.0.0+-- GHC 7.8.4 released with 0.3.1.0 license: BSD3 license-file: LICENSE category: GHC@@ -14,12 +14,8 @@ source-repository head type: git- location: http://git.haskell.org/packages/ghc-prim.git--source-repository this- type: git- location: http://git.haskell.org/packages/ghc-prim.git- tag: ghc-prim-0.3.1.0-release+ location: http://git.haskell.org/ghc.git+ subdir: libraries/ghc-prim flag include-ghc-prim Description: Include GHC.Prim in exposed-modules@@ -56,12 +52,15 @@ exposed-modules: GHC.Prim c-sources:+ cbits/atomic.c cbits/bswap.c+ cbits/clz.c+ cbits/ctz.c cbits/debug.c cbits/longlong.c cbits/popcnt.c cbits/word2float.c - -- We need to set the package name to ghc-prim (without a version number)+ -- We need to set the package key to ghc-prim (without a version number) -- as it's magic.- ghc-options: -package-name ghc-prim+ ghc-options: -this-package-key ghc-prim