!L0      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[ \ ] ^ _ ` a b cdefghijklmnopqr s t u v w x y z { | } ~         !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                  ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ 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 { | } ~                               !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ (c) Alexey Kuleshevich 2020BSD3(Alexey Kuleshevich <alexey@kuleshevi.ch> experimental non-portableNoneFHVBrprimal5A class for monads in which exceptions may be thrown.(Instances should obey the following law: throwM e >> x = throwM eZIn other words, throwing an exception short-circuits the rest of the monadic computation.NoteThis is an identical class to  Yhttps://hackage.haskell.org/package/exceptions/docs/Control-Monad-Catch.html#t:MonadThrow MonadThrow from  exceptionsn package. The reason why it was copied, instead of a direct depency on the aforementioned package is because  MonadCatch and  MonadMaskO are not right abstractions for exception handling in presence of concurrency.sprimalPThrow an exception. Note that this throws when this action is run in the monad m5, not when it is applied. It is a generalization of Control.Exception's .Should satisfy the law: throwM e >> f = throwM ersrs(c) Alexey Kuleshevich 2020BSD3(Alexey Kuleshevich <alexey@kuleshevi.ch> experimental non-portableNone =>?@ACFSXM= primalConstruct a primitive actionprimalUnwrap a primitive actionprimal"A shorter synonym for the magical primal;Construct a primitive action that does not return anything.primalLift an  action to  with the + state token. Type restricted synonym for primalLift an  action to 9 with the same state token. Type restricted synonym for primalLift an action from the  to another  with the same state token.primal Restrict a  action that works with  to .primal Restrict a  action that works in .(c) Alexey Kuleshevich 2020BSD3(Alexey Kuleshevich <alexey@kuleshevi.ch> experimental non-portableNone>FXuNprimal Unwrap any & action while coercing the state tokenHighly unsafe!primal Unwrap any F action that does not return anything, while coercing the state tokenHighly unsafe!primal Convert a  action to another  while coercing the state token.Highly unsafe!primal Convert a  action to  while coercing the state token s.Highly unsafe!primal Convert a  action to # while coercing the state token to .Highly unsafe!primal Convert an  action to some  while coercing the state token.Highly unsafe!It is similar to ,, except resulting action can be any other . action, therefore it is a lot more dangerous.primal Convert an  action to some  while coercing the state token.Highly unsafe!primalSame as , except works in any .primalSame as p, except works not only with , but with other # actions as well. Reading and writing values into memory is safe, as long as writing action is idempotent. On the other hand things like memory or resource allocation, exceptions handling are not safe at all, since supplied action can be run multiple times and a copy interrupted at will.primalTake an B and compute it as a pure value, while inlining the action itself.Ridiculously unsafe!#This is even more unsafe then both q and :.The only time it is really safe to use is on idempotent action that only read values from memory, but do note do any mutation, allocation and certainly not interaction with real world.In  yhttps://github.com/haskell/bytestring/blob/95fe6bdf13c9cc86c1c880164f7844d61d989574/Data/ByteString/Internal.hs#L566-L592 `bytestring` it is known as accursedUnutterablePerformIO6. Here are some resources that discuss it's unsafety: }https://stackoverflow.com/questions/61021205/what-is-the-difference-between-unsafedupableperformio-and-accursedunutterableperStack overflow question bhttps://www.reddit.com/r/haskell/comments/2cbgpz/flee_traveller_flee_or_you_will_be_corrupted_and/Reddit discussionprimalTake an L and compute it as a pure value, while inlining the action itself. Same as .Ridiculously unsafe!primal Take any L action and compute it as a pure value, while inlining the action. Same as , but applied to any  action.Ridiculously unsafe!primalSame as o, except works in any primalSame as :, except works in any primal A version of  that coerce the state token.Highly unsafe!:opqqpo: (c) Alexey Kuleshevich 2020BSD3(Alexey Kuleshevich <alexey@kuleshevi.ch> experimental non-portableNone>FSX}primalThis is the same as s, but restricted to primalSame as , but generalized to primal Similar to throwTo from  Shttps://hackage.haskell.org/package/unliftio/docs/UnliftIO-Exception.html#v:throwTounliftio4 this will wrap any known non-async exception with ", because otherwise semantics of 6 with respect to asynchronous exceptions are violated.rs (c) Alexey Kuleshevich 2020BSD3(Alexey Kuleshevich <alexey@kuleshevi.ch> experimental non-portableNone >FSXz primal Wrapper for N. Sleep specified number of microseconds. Not designed for threaded runtime: Errors when compiled with  -threadedprimal Wrapper for 7. Block and wait for input to become available on the %. Not designed for threaded runtime: Errors when compiled with  -threadedprimal Wrapper for 1. Block and wait until output is possible on the &. Not designed for threaded runtime: Errors when compiled with  -threadedprimalWrapper around  . Unlike d it does not install any exception handlers on the action, so you need make sure to do it yourself.primalWrapper around   . Unlike d it does not install any exception handlers on the action, so you need make sure to do it yourself.primalWrapper around  , which throws  & exception in the target thread. Use 0 if you want a different exception to be thrown.primalWrapper around  .primalWrapper around  .primal4Pointer should refer to UTF8 encoded string of bytesprimal#Something that is not available in base . Convert a  to a regular integral type. (c) Alexey Kuleshevich 2020BSD3(Alexey Kuleshevich <alexey@kuleshevi.ch> experimental non-portableNone>FSX.primalnThis is an action that ensures that the value is still available and garbage collector has not cleaned it up.PMake sure not to use it after some computation that doesn't return, like after forever for example, otherwise touch will simply be removed by ghc and bad things will happen. If you have a case like that, make sure to use  or  instead.primalDAn action that evaluates a value to weak head normal form. Same as , except it works in a primalPForward compatible operator that might be introduced in some future ghc version.See: 8https://gitlab.haskell.org/ghc/ghc/-/merge_requests/3131!3131Current version is not as efficient as the version that will be introduced in the future, because it works around the ghc bug by simply preventing inlining and relying on the  function.primal Similar to . See  withAlive# for more info.primal Similar to . See  withAlive# for more info.primalThe value to preserveprimal5The continuation in which the value will be preservedprimalThe value to preserveprimal2Action to run in which the value will be preservedprimalThe value to preserveprimal2Action to run in which the value will be preserved(c) Alexey Kuleshevich 2020BSD3(Alexey Kuleshevich <alexey@kuleshevi.ch> experimental non-portableNoneprimal2Helper function that converts a type into a string? !"#$%&'()*+,-./012345678(c) Alexey Kuleshevich 2020BSD3(Alexey Kuleshevich <alexey@kuleshevi.ch> experimental non-portableNone>FyprimalMakes a >X for an arbitrary object. The object passed as the first argument is not evaluated by .primal Similar to  Vhttp://hackage.haskell.org/package/stable-maps/docs/System-Mem-StableName-Dynamic.html`makeDynamicStableName`, but returns > 9 and is generalized to primalOrphan instance defined in Data.Prim.StableName;<>=>=<;(c) Alexey Kuleshevich 2020BSD3(Alexey Kuleshevich <alexey@kuleshevi.ch> experimental non-portableNone FM 6ZY(c) Alexey Kuleshevich 2020BSD3(Alexey Kuleshevich <alexey@kuleshevi.ch> experimental non-portableNone =?FXprimal1Helper function for converting casBool IO actionsprimal ,https://en.wikipedia.org/wiki/Memory_barrierMemory barrierF. This will ensure that the cache is fully updated before continuing.!      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~(c) Alexey Kuleshevich 2020BSD3(Alexey Kuleshevich <alexey@kuleshevi.ch> experimental non-portableNone F1primal@Slightly slower reimplementation of newer primops using the old :Modify the contents of a ;j, returning the previous contents and the result of applying the given function to the previous contents.Warning:+ this can fail with an unchecked exception.primal@Slightly slower reimplementation of newer primops using the old :Modify the contents of a ;j, returning the previous contents and the result of applying the given function to the previous contents.Warning:+ this can fail with an unchecked exception.2  !"#$%&'()*+,-./0123456ZY(c) Alexey Kuleshevich 2020BSD3(Alexey Kuleshevich <alexey@kuleshevi.ch> experimental non-portableNone F_ؽprimalBecause GC is guaranteed not to move unpinned memory during the unsafe FFI call we can compare memory pointers on the C side. Because the addresses cannot change underneath us we can safely guarantee pointer equality for the same pinned or unpinned arrays primal&Convert memcmp result into an orderingprimal Source Ptrprimal!Offset in bytes into source arrayprimal Destinationprimal Offset in bytes into destinationprimalNumber of bytes to copyprimal Source arrayprimal!Offset in bytes into source arrayprimalDestination ptrprimal Offset in bytes into destinationprimalNumber of bytes to copyprimal Source arrayprimal!Offset in bytes into source arrayprimal Destinationprimal Offset in bytes into destinationprimalNumber of bytes to copyprimal Source ptrprimal!Offset in bytes into source arrayprimalDestination ptrprimal Offset in bytes into destinationprimalNumber of bytes to copyo  !"#$%&'()*+,-./0123456ZY      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~  (c) Alexey Kuleshevich 2020BSD3(Alexey Kuleshevich <alexey@kuleshevi.ch> experimental non-portableNone F primalCast a Double into a 64bit Word primalCast a 64bit Word into a Double primalCast a Float into a 32bit WordprimalCast a 32bit Word into a Float   (c) Alexey Kuleshevich 2020BSD3(Alexey Kuleshevich <alexey@kuleshevi.ch> experimental non-portableNoneF<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuv;wxyz{|}~9      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~    !"#$%&'()*+,-./0123456     : !"#$%&'()*+,-./01234567    89:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                           ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ 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 { | } ~  ZY       !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~     x ( )*-+, .!/"0#1$2%3&4'56ZY       !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~     (c) Alexey Kuleshevich 2020BSD3(Alexey Kuleshevich <alexey@kuleshevi.ch> experimental non-portableNone-.8=>?FHMUVX_primal Invariants:<Reading should never fail on memory that contains only zeros%Writing should always overwrite all of the bytes allocated for the element. In other words, writing to a dirty (uninitilized) region of memory should never leave any garbage around. For example, if a type requires 31 bytes of memory then on any write all 31 bytes must be overwritten.9A single thread write/read sequence must always roundtripkThis is not a class for serialization, therefore memory layout of unpacked datatype is selfcontained in { class and representation is not expected to stay the same between different versions of software. Primitive types like a, y, X6 are an exception to this rule for obvious reasons.primalReturned value must match the  type level NatprimalReturned value must match the  type level Nat%primalUSet the region of MutableByteArray to the same value. Offset is in number of elements&primalKSet the region of memory to the same value. Offset is in number of elements)primalA loop that uses # to set the values in the region. It is a suboptimal way to fill the memory with a single value that is why it is only provided here for convenience [\]^`_ba !"#$%&'()*+  !"#$%&)*+'(`_^]ba\[(c) Alexey Kuleshevich 2020BSD3(Alexey Kuleshevich <alexey@kuleshevi.ch> experimental non-portableNone18=>?FHMVXw primalRead an element from o) atomically. Implies full memory barrier.primalWrite an element into o) atomically. Implies full memory barrier.primalDRead an element from memory atomically. Implies full memory barrier.primalNWrite an element directly into memory atomically. Implies full memory barrier.primalCompare-and-swap (CAS) operation. Given a mutable array, offset in number of elements, an old value and a new value atomically swap the old value for the new one, but only if the actual old value was an exact match to the expetced old one that was supplied. Returns the actual old value, which if compared to supplied expected one will tell us whether atomic swap occured or not.primalUsing 1 perform atomic modification of an element in a o@. This is essentially an implementation of a spinlock using CAS.primalUsing 1 perform atomic modification of an element in a OffAddr#@. This is essentially an implementation of a spinlock using CAS.primalUsing 1 perform atomic modification of an element in a o@. This is essentially an implementation of a spinlock using CAS.primalUsing 1 perform atomic modification of an element in a o. Returns the previous value.primalUsing 1 perform atomic modification of an element in a o. Returns the previous value.primalUsing 1 perform atomic modification of an element in a o. Returns the new value.primalUsing 1 perform atomic modification of an element in a o.primalUsing 1 perform atomic modification of an element in a OffAddr#@. This is essentially an implementation of a spinlock using CAS.primalUsing 1 perform atomic modification of an element in a OffAddr#. Returns the previous value.primalUsing 1 perform atomic modification of an element in a OffAddr#. Returns the new value.primalUsing 1 perform atomic modification of an element in a OffAddr#.primalFlip all bits atomically in the element of an array at the supplied offset. Returns the previous value. Implies full memory barrier.primalFlip all bits atomically in the element of an array at the supplied offset. Returns the new value. Implies full memory barrier.primalFlip all bits atomically in the element of an array at the supplied offset. Returns the previous value. Implies full memory barrier.primalFlip all bits atomically in the element of an array at the supplied offset. Returns the new value. Implies full memory barrier.primal%Available only on 64bit architecturesprimal%Available only on 64bit architecturesprimal%Available only on 64bit architecturesprimal%Available only on 64bit architectures primal%Available only on 64bit architectures!primal%Available only on 64bit architectures"primal%Available only on 64bit architectures#primal%Available only on 64bit architecturesDprimal%Available only on 64bit architecturesEprimal%Available only on 64bit architecturesFprimal%Available only on 64bit architecturesGprimal%Available only on 64bit architecturesprimal&Mutable array to read the element fromprimal+Offset into the array in number of elementsprimal'Mutable array to write the element intoprimal+Offset into the array in number of elementsprimalElement to writeprimal"Pointer to the beginning of memoryprimal6Offset in number of elements from the supplied pointerprimal"Pointer to the beginning of memoryprimal6Offset in number of elements from the supplied pointerprimalElement to writeprimalArray to be mutatedprimal+Offset into the array in number of elementsprimalExpected old valueprimal New valueprimalStarting stateprimalArray to be mutatedprimal+Offset into the array in number of elementsprimalExpected old valueprimal New valueprimalStarting stateprimalArray to be mutatedprimalIndex in number of ` elements into the oprimal0Function to be applied atomically to the elementprimalStarting stateprimalArray to be mutatedprimalIndex in number of ` elements into the OffAddr#primal0Function to be applied atomically to the elementprimalStarting stateprimalArray to be mutatedprimalIndex in number of ` elements into the oprimal0Function to be applied atomically to the elementprimalStarting stateprimalArray to be mutatedprimalIndex in number of ` elements into the oprimal0Function to be applied atomically to the elementprimalStarting stateprimalArray to be mutatedprimalIndex in number of ` elements into the oprimal0Function to be applied atomically to the elementprimalStarting stateprimalArray to be mutatedprimalIndex in number of ` elements into the oprimal0Function to be applied atomically to the elementprimalStarting stateprimalArray to be mutatedprimalIndex in number of ` elements into the oprimal0Function to be applied atomically to the elementprimalStarting stateprimalArray to be mutatedprimalIndex in number of ` elements into the OffAddr#primal0Function to be applied atomically to the elementprimalStarting stateprimalArray to be mutatedprimalIndex in number of ` elements into the OffAddr#primal0Function to be applied atomically to the elementprimalStarting stateprimalArray to be mutatedprimalIndex in number of ` elements into the OffAddr#primal0Function to be applied atomically to the elementprimalStarting stateprimalArray to be mutatedprimalIndex in number of ` elements into the OffAddr#primal0Function to be applied atomically to the elementprimalStarting state22(c) Alexey Kuleshevich 2020BSD3(Alexey Kuleshevich <alexey@kuleshevi.ch> experimental non-portableNone.1=>?FHMUVX primalAtomic reads on P require a lock because otherwise any other thread can overwrite the contnts in the midst of reading, resulting in a value with contents from both values part before and part after the write. primaluValues are no longer guaranteed to be one word in size, as such in order for writes to be atomic we require locking. primalSame as   , but for T with offset primalSame as   , but for T with offset!PQRSTUVWXYZ[\]^_`abcdefghijklmnop!PQRSTUVWXYZ[\]^_`abcdefghijklmnop(c) Alexey Kuleshevich 2020BSD3(Alexey Kuleshevich <alexey@kuleshevi.ch> experimental non-portableNone FHMVXprimalOffset in number of elementsprimalNumber of elementsprimalBGet the size of the data type in bytes. Argument is not evaluated.import Data.PrimbyteCount (Just 'a')Count {unCount = 5}primalSame as sizeOf?, except that the type can be supplied as a type level argument:set -XTypeApplicationsimport Data.PrimbyteCountType @Int64Count {unCount = 8}primalSame as sizeOf, but argument is a X of a, instead of the type itself.import Data.Primimport Data.Proxy%byteCountProxy (Proxy :: Proxy Int64)Count {unCount = 8}primalBGet the alignemnt of the type in bytes. Argument is not evaluated.primalSame as ,, except that the type can be supplied with TypeApplications:set -XTypeApplicationsimport Data.PrimalignmentType @Int324primalSame as , but argument is a X of a, instead of the type itself.import Data.Proxy%alignmentProxy (Proxy :: Proxy Int64)8primalBCovert an element count to number of bytes it coresponds to as an a. See  for preserving the  wrapper.primalCovert to the  of bytesprimal*Cast a count to an offset of the same typeprimal$Helper noop function that restricts  to the type of proxyprimalRestrict type argument of H to the same type as the second argument, which itself is not evaluatedprimal"Compute how many elements of type e) can fit in the supplied number of bytes.primal$Helper noop function that restricts set to the type of proxyprimalRestrict type argument of H to the same type as the second argument, which itself is not evaluatedprimal9Cast an offset to count. Useful for dealing with regions.import Data.Prim#totalCount = Count 10 :: Count WordstartOffset = Off 4 :: Off Word#totalCount - offToCount startOffsetCount {unCount = 6}primal1Convert an offset in elements to count in bytres.primal&Compute byte offset from an offset of  typetoByteOff (10 :: Off Word64)Off {unOff = 80}primal Convert an offset for some type e with ( instance to the number of bytes as an a.unOffBytes (10 :: Off Word64)80primal0Convert offset of some type into number of bytesK acehky{}7 A@? DCBGFEJIHMLKPONSRQVUTXW PQRPPQR7XWA@?DCBGFEJIHMLKPONSRQVUT(c) Alexey Kuleshevich 2020BSD3(Alexey Kuleshevich <alexey@kuleshevi.ch> experimental non-portableNone>FuprimalcFind the offset in bytes that is between the two pointers by subtracting one address from another.primalFind the offset in number of elements that is between the two pointers by subtracting one address from another and dividing the result by the size of an element.primalSame as @, but will also return the remainder in bytes that is left over.primalmCompare memory between two pointers. Offsets and count is in number of elements, instead of byte count. Use " when offset in bytes is required.primalSame as :, except offset is in bytes instead of number of elements.primal1Perform atomic modification of an element in the = at the supplied index. Returns the artifact of computation bV. Offset is in number of elements, rather than bytes. Implies a full memory barrier.Note= - Bounds are not checked, therefore this function is unsafe.primal1Perform atomic modification of an element in the = at the supplied index. Returns the artifact of computation bV. Offset is in number of elements, rather than bytes. Implies a full memory barrier.Note= - Bounds are not checked, therefore this function is unsafe.primal1Perform atomic modification of an element in the m at the supplied index. Offset is in number of elements, rather than bytes. Implies a full memory barrier.Note= - Bounds are not checked, therefore this function is unsafe.primal1Perform atomic modification of an element in the  at the supplied index. Returns the previous value. Offset is in number of elements, rather than bytes. Implies a full memory barrier.Note= - Bounds are not checked, therefore this function is unsafe.primal1Perform atomic modification of an element in the m at the supplied index. Offset is in number of elements, rather than bytes. Implies a full memory barrier.Note= - Bounds are not checked, therefore this function is unsafe.primal'Add a numeric value to an element of a , corresponds to ( ) done atomically. Returns the previous value. Offset is in number of elements, rather than bytes. Implies a full memory barrier.Note= - Bounds are not checked, therefore this function is unsafe.primal'Add a numeric value to an element of a , corresponds to ( )~ done atomically. Returns the new value. Offset is in number of elements, rather than bytes. Implies a full memory barrier.Note= - Bounds are not checked, therefore this function is unsafe.primal.Subtract a numeric value from an element of a , corresponds to ( ) done atomically. Returns the previous value. Offset is in number of elements, rather than bytes. Implies a full memory barrier.Note= - Bounds are not checked, therefore this function is unsafe.primal.Subtract a numeric value from an element of a , corresponds to ( )| done atomically. Returns the new value. Offset is in number of elements, rather than bytes. Implies a full memory barrier.Note= - Bounds are not checked, therefore this function is unsafe.primal,Binary conjunction (AND) of an element of a * with the supplied value, corresponds to ( ) done atomically. Returns the previous value. Offset is in number of elements, rather than bytes. Implies a full memory barrier.Note= - Bounds are not checked, therefore this function is unsafe.primal,Binary conjunction (AND) of an element of a * with the supplied value, corresponds to ( )| done atomically. Returns the new value. Offset is in number of elements, rather than bytes. Implies a full memory barrier.Note= - Bounds are not checked, therefore this function is unsafe.primal9Negation of binary conjunction (NAND) of an element of a * with the supplied value, corresponds to \x y -> ! (x   y) done atomically. Returns the previous value. Offset is in number of elements, rather than bytes. Implies a full memory barrier.Note= - Bounds are not checked, therefore this function is unsafe.primal:Negation of binary conjunction (NAND) of an element of a * with the supplied value, corresponds to \x y -> ! (x   y)} done atomically. Returns the new value. Offset is in number of elements, rather than bytes. Implies a full memory barrier.Note= - Bounds are not checked, therefore this function is unsafe.primal+Binary disjunction (OR) of an element of a * with the supplied value, corresponds to (") done atomically. Returns the previous value. Offset is in number of elements, rather than bytes. Implies a full memory barrier.Note= - Bounds are not checked, therefore this function is unsafe.primal+Binary disjunction (OR) of an element of a * with the supplied value, corresponds to (")| done atomically. Returns the new value. Offset is in number of elements, rather than bytes. Implies a full memory barrier.Note= - Bounds are not checked, therefore this function is unsafe.primal6Binary exclusive disjunction (XOR) of an element of a * with the supplied value, corresponds to # done atomically. Returns the previous value. Offset is in number of elements, rather than bytes. Implies a full memory barrier.Note= - Bounds are not checked, therefore this function is unsafe.primal6Binary exclusive disjunction (XOR) of an element of a * with the supplied value, corresponds to #| done atomically. Returns the new value. Offset is in number of elements, rather than bytes. Implies a full memory barrier.Note= - Bounds are not checked, therefore this function is unsafe.primal)Binary negation (NOT) of an element of a , corresponds to (!) done atomically. Returns the previous value. Offset is in number of elements, rather than bytes. Implies a full memory barrier.Note= - Bounds are not checked, therefore this function is unsafe.primal)Binary negation (NOT) of an element of a , corresponds to (!)| done atomically. Returns the new value. Offset is in number of elements, rather than bytes. Implies a full memory barrier.Note= - Bounds are not checked, therefore this function is unsafe.primalSame as  primalChunk of memory to fillprimalOffset in number of elementsprimalNumber of cells to fillprimalA value to fill the cells withprimalArray to be mutatedprimalIndex is in elements of a, rather than bytes.primalExpected old valueprimal New valueprimalArray to be mutatedprimalIndex is in elements of a, rather than bytes.primalbFunction that is applied to the old value and returns new value and some artifact of computation bprimalArray to be mutatedprimalIndex is in elements of a, rather than bytes.primal@Function that is applied to the old value and returns new value.primalArray to be mutatedprimalIndex is in elements of a, rather than bytes.primalCFunction that is applied to the old value and returns the new valueprimalArray to be mutatedprimalIndex is in elements of a, rather than bytes.primalCFunction that is applied to the old value and returns the new valueC[\]^`_baefghijklmAefghijklm`_^]ba\[(c) Alexey Kuleshevich 2020BSD3(Alexey Kuleshevich <alexey@kuleshevi.ch> experimental non-portableNone> 3primalSame as  , but generalized to primalSame as  , but generalized to primalSame as  , but generalized to 8cd8dc(c) Alexey Kuleshevich 2020BSD3(Alexey Kuleshevich <alexey@kuleshevi.ch> experimental non-portableNone>F0b primalSame as $%W, except it requires a finalizer to be supplied. For a version without finalizers use primal Similar to ), except it does not require a finalizer.primalSame as $&W, except it requires a finalizer to be supplied. For a version without finalizers use primal Similar to ), except it does not require a finalizer.primalSame as $'.primal7Add a foreign function finalizer with a single argumentprimal3Add a foreign function finalizer with two argumentsprimal Similar to $(primal Similar to $)primalHPointer to the C function to be called when finalizers are being invokedprimal8Argument that will be supplied to the finalizer functionprimalHPointer to the C function to be called when finalizers are being invokedprimal>First argument that will be supplied to the finalizer functionprimal?Second argument that will be supplied to the finalizer function n9 n9 *+,*+-*+.*/0*+1234*56*78*7923:23;23<23=23>23?23@23A23B23C23D23E23F23G23H23I23J23K23L23M23N23O23P23Q23R23S23T23U23V23W23X23Y23Z23[23\23]23^23_23`23a23b23c23d23e23f23g*hi*56*jk*lm*no*np*nq*nq*rs*rt*rt*uv*uw*uw*ux*uy*uy*uz*u{*u{*u|*u}*u}*u~*u*u*u*u*u*u*u*u*************5*5*7*7*7*7*7*7*7*7*7*jk*l*l*l          !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<= > ? @ 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 { | } ~                                                                        !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyzz{|}~     %&'( 2!"*#$*l%*&*'(23)23**+,23-23.23/230*'1232233*45*67*+8*+9*+:*+;*+<*+=*+>*+?*@A*@B*6C*6D*6E*6F*6G*6H*6I*6J*6K*6L*6M*6N*6O*6P*@Q*RS*RT*RU*RV*WX*+Y*+Z*+[*+\*+]*+^*+_*+`*+a*+b*+c2!}23d23e*+f*+g23h23i23j23k23l2mn2mo2mp*+q*+r2ms*tu23v23w*tx*ty*tz*t{*t|23}*~*~232323232!2!232!2!232!2!232!2!****23**23**23232323232!2323232323232!2!****23**23**2323*78*7923232!2!2!2!2!2!2!2!2!2!2!2!2!2!2!2!2!2!2!2!2!2!2!2!2!2!2!2!2!2!2!2!2!23232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323 23 23 23 23 23232323232323232323232323232323232323 23!23"23#23$23%23&23'23(23)23*23+23,23-23.23/23023123223323423523623723823923:23;23<23=23>23?23@23A23B23C23D23E23F23G23H23I23J23K23L23M23N23O23P23Q23R23S23T23U23V23W23X23Y23Z23[23\23]23^23_23`23a23b23c23d23e23f23g23h23i23j23k23l23m23n23o23p23q23r23s23t23u23v23w23x23y23z23{23|23}23~23232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323 23 23 23 23 23232323232323232323232323232323232323 23!23"23#23$23%23&23'23(23)23*23+23,23-23.23/23023123223323423523623723823923:23;23<23=23>23?23@23A23B23C23D23E23F23G23H23I23J23K23L23M23N23O23P23Q23R23S23T23U23V23W23X23Y23Z23[23\23]23^23_23`23a23b23c23d23e23f23g23h23i23j23k23l23m23n23o23p23q23r23s23t23u23v23w23x23y23z23{23|23}23~23232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323 23 23 23 23 23232323232323232323232323232323232323 23!23"23#23$23%23&23'23(23)23*23+23,23-23.23/23023123223323423523623723823923:23;23<23=23>23?23@23A23B23C23D23E23F23G23H23I23J23K23L23M23N23O23P23Q23R23S23T23U23V23W23X23Y23Z23[23\23]23^23_23`23a23b23c23d23e23f23g23h23i23j23k23l23m23n23o23p23q23r23s23t23u23v23w23x23y23z23{23|23}23~23232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323 23 23 23 23 23232323232323232323232323232323232323 23!23"23#23$23%23&23'23(23)23*23+23,23-23.23/23023123223323423523623723823923:23;23<23=23>23?23@23A23B23C23D23E23F23G23H23I23J23K23L23M23N23O23P23Q23R23S23T23U23V23W23X23Y23Z23[23\23]23^23_23`23a23b23c23d23e23f23g23h23i23j23k23l23m23n23o23p23q23r23s23t23u23v23w23x23y23z23{23|23}23~23232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323 23 23 23 23 23 23 23 23 23 23 23 23 23 23 23 23 23 23 23 23 23 23 23 23 23 23 23 23 23 23 23 23 23 !23 "23 #23 $23 %23 &* '* (* )* ** +* ,* -* .* /* 0* 1* 2* 3* 4* 5* 6* 7* 8* 9* :* ;* <* =* >* ?* @* A* B* C* D* E* F* G* H* I* J* K* L* M* N* O* P* Q* R* S* T* U* V2 W X2 W Y2 W Z2 W [2 W \2 W ]2 W ^2 W _2 W `2 W a2 W b2 W c*t d*t e*t f*t g*t h*t i*t j*+ k*+ k*+ l*+ l*+ m*+ m*+ n*+ n*+ o*+ o*+ p*+ p*+ q*+ q*+ r*+ r*+ s*+ s*+ t*+ t*+ u*+ u*+ v*+ v*+ w*+ w*+ x*+ x*+ y*+ y*+ z*+ z*+ {*+ {*+ |*+ |*+ }*+ }*+ ~*+ ~*+ *+ *+,*+ *+ *+ *+ *+ *+ *+ *+ *+ *+ *+ *+ *+ *  *  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *+ *+ *+ *+ *+ 2!     *+ *+ *+ *+ * * * * *  *  * *  *  * *  *  *  *  *  *  * *  *  * *  *  * *  *  * *u *u *u * * **5*5*5 %primal-0.2.0.0-9Z2xO2cZcdkIq350JNtMUj Data.PrimControl.Prim.MonadForeign.Prim.StablePtrForeign.Prim.Ptr Foreign.PrimForeign.Prim.WeakPtrControl.Prim.Monad.UnsafeData.Prim.StableNameData.Prim.ClassControl.Prim.Monad.ThrowControl.Prim.ExceptionControl.Prim.ConcurrentControl.Prim.EvalData.Prim.AtomicData.Prim.AtomControlExceptionthrowIOControl.Prim.Monad.InternalControl.Monad.ST.Unsafe unsafeSTToIOControl.ConcurrentforkIOforkOnControl.ExceptionevaluateForeign.Prim.C.LtGHC802Foreign.Prim.C.AtomicForeign.Prim.C.LtGHC806Foreign.Prim.CForeign.Prim.Cmm Data.Bits.&. complement.|.xorSystem.Mem.WeakmkWeak mkWeakPtr addFinalizer deRefWeakfinalizebaseGHC.BasememptymappendmconcatData.Typeable.InternalTypeableMonoidghc-primGHC.Prim RealWorld GHC.Stable StablePtrGHC.PtrPtrFunPtrisMutableByteArrayPinned#isByteArrayPinned#getSizeofMutableByteArray#indexWord8ArrayAsChar#indexWord8ArrayAsWideChar#indexWord8ArrayAsAddr#indexWord8ArrayAsFloat#indexWord8ArrayAsDouble#indexWord8ArrayAsStablePtr#indexWord8ArrayAsInt16#indexWord8ArrayAsInt32#indexWord8ArrayAsInt64#indexWord8ArrayAsInt#indexWord8ArrayAsWord16#indexWord8ArrayAsWord32#indexWord8ArrayAsWord64#indexWord8ArrayAsWord#readWord8ArrayAsChar#readWord8ArrayAsWideChar#readWord8ArrayAsAddr#readWord8ArrayAsFloat#readWord8ArrayAsDouble#readWord8ArrayAsStablePtr#readWord8ArrayAsInt16#readWord8ArrayAsInt32#readWord8ArrayAsInt64#readWord8ArrayAsInt#readWord8ArrayAsWord16#readWord8ArrayAsWord32#readWord8ArrayAsWord64#readWord8ArrayAsWord#writeWord8ArrayAsChar#writeWord8ArrayAsWideChar#writeWord8ArrayAsAddr#writeWord8ArrayAsFloat#writeWord8ArrayAsDouble#writeWord8ArrayAsStablePtr#writeWord8ArrayAsInt16#writeWord8ArrayAsInt32#writeWord8ArrayAsInt64#writeWord8ArrayAsInt#writeWord8ArrayAsWord16#writeWord8ArrayAsWord32#writeWord8ArrayAsWord64#writeWord8ArrayAsWord#compareByteArrays#GHC.ForeignPtr ForeignPtrGHC.WeakWeak GHC.IO.UnsafeunsafeDupableInterleaveIOGHC.StableName eqStableNamehashStableName StableName Data.MonoidgetApApData.Semigroup.InternalgetDualDualappEndoEndogetAllAllgetAnyAnygetSumSum getProductProductgetAltAlt Data.ProxyProxyForeign.C.TypesCBool Foreign.Ptr intPtrToPtr ptrToIntPtr wordPtrToPtr ptrToWordPtrWordPtrIntPtrcastPtrToStablePtrcastStablePtrToPtrcastPtrToFunPtrcastFunPtrToPtr castFunPtr nullFunPtrminusPtralignPtrplusPtrcastPtrnullPtrunsafeInterleaveIOunsafeDupablePerformIOunsafePerformIO MonadThrowthrowM$fMonadThrowSelectT$fMonadThrowAccumT$fMonadThrowWriterT$fMonadThrowWriterT0$fMonadThrowStateT$fMonadThrowStateT0$fMonadThrowRWST$fMonadThrowRWST0$fMonadThrowReaderT$fMonadThrowMaybeT$fMonadThrowIdentityT$fMonadThrowExceptT$fMonadThrowContT$fMonadThrowSTM$fMonadThrowST$fMonadThrowIO$fMonadThrowEither$fMonadThrowMaybe MonadPrimprimMonadUnliftPrimwithRunInPrimBase MonadPrimBaseprimBaseRW runInPrimBase primBase_prim_ liftPrimIO liftPrimST liftPrimBase primBaseToIO primBaseToSTunsafePrimBaseunsafePrimBase_unsafePrimBaseToPrimunsafePrimBaseToSTunsafePrimBaseToIOunsafeIOToPrimunsafeSTToPrimnoDuplicatePrimunsafeDupablePerformPrimBaseunsafeInlineIOunsafeInlineSTunsafeInlinePrimBaseunsafeInterleavePrimBaseunsafeDupableInterleavePrimBaseunsafeLiftPrimBaseisSyncExceptionisAsyncException throwPrimcatchcatchAny catchAnySynccatchAll catchAllSyncmaskAsyncExceptionsunmaskAsyncExceptionsmaskUninterruptiblegetMaskingStatethrowTo getThreadIdspark numSparks runSparksdelaywaitRead waitWritefork killThreadyield myThreadId labelThreadisCurrentThreadBoundPrim threadStatusthreadCapabilitythreadIdToCIntid2TSOtouchseqPrim keepAlive#withAlivePrimBasewithAliveUnliftPrim showsTypemakeStableNamemakeAnyStableName$fShowStableNamesyncXorFetchNewWord64ArrayIOsyncXorFetchNewWord64AddrIOsyncXorFetchNewInt64ArrayIOsyncXorFetchNewInt64AddrIOsyncXorFetchOldWord64ArrayIOsyncXorFetchOldWord64AddrIOsyncXorFetchOldInt64ArrayIOsyncXorFetchOldInt64AddrIOsyncOrFetchNewWord64ArrayIOsyncOrFetchNewWord64AddrIOsyncOrFetchNewInt64ArrayIOsyncOrFetchNewInt64AddrIOsyncOrFetchOldWord64ArrayIOsyncOrFetchOldWord64AddrIOsyncOrFetchOldInt64ArrayIOsyncOrFetchOldInt64AddrIOsyncNandFetchNewWord64ArrayIOsyncNandFetchNewWord64AddrIOsyncNandFetchNewInt64ArrayIOsyncNandFetchNewInt64AddrIOsyncNandFetchOldWord64ArrayIOsyncNandFetchOldWord64AddrIOsyncNandFetchOldInt64ArrayIOsyncNandFetchOldInt64AddrIOsyncAndFetchNewWord64ArrayIOsyncAndFetchNewWord64AddrIOsyncAndFetchNewInt64ArrayIOsyncAndFetchNewInt64AddrIOsyncAndFetchOldWord64ArrayIOsyncAndFetchOldWord64AddrIOsyncAndFetchOldInt64ArrayIOsyncAndFetchOldInt64AddrIOsyncSubFetchNewWord64ArrayIOsyncSubFetchNewWord64AddrIOsyncSubFetchNewInt64ArrayIOsyncSubFetchNewInt64AddrIOsyncSubFetchOldWord64ArrayIOsyncSubFetchOldWord64AddrIOsyncSubFetchOldInt64ArrayIOsyncSubFetchOldInt64AddrIOsyncAddFetchNewWord64ArrayIOsyncAddFetchNewWord64AddrIOsyncAddFetchNewInt64ArrayIOsyncAddFetchNewInt64AddrIOsyncAddFetchOldWord64ArrayIOsyncAddFetchOldWord64AddrIOsyncAddFetchOldInt64ArrayIOsyncAddFetchOldInt64AddrIOsyncCasWord64ArrayIOsyncCasWord64AddrIOsyncCasInt64ArrayIOsyncCasInt64AddrIOsyncCasWord64BoolArrayIOsyncCasWord64BoolAddrIOsyncCasInt64BoolArrayIOsyncCasInt64BoolAddrIOsyncXorFetchNewWordArrayIOsyncXorFetchNewWordAddrIOsyncXorFetchNewIntArrayIOsyncXorFetchNewIntAddrIOsyncXorFetchOldWordArrayIOsyncXorFetchOldWordAddrIOsyncXorFetchOldIntArrayIOsyncXorFetchOldIntAddrIOsyncOrFetchNewWordArrayIOsyncOrFetchNewWordAddrIOsyncOrFetchNewIntArrayIOsyncOrFetchNewIntAddrIOsyncOrFetchOldWordArrayIOsyncOrFetchOldWordAddrIOsyncOrFetchOldIntArrayIOsyncOrFetchOldIntAddrIOsyncNandFetchNewWordArrayIOsyncNandFetchNewWordAddrIOsyncNandFetchNewIntArrayIOsyncNandFetchNewIntAddrIOsyncNandFetchOldWordArrayIOsyncNandFetchOldWordAddrIOsyncNandFetchOldIntArrayIOsyncNandFetchOldIntAddrIOsyncAndFetchNewWordArrayIOsyncAndFetchNewWordAddrIOsyncAndFetchNewIntArrayIOsyncAndFetchNewIntAddrIOsyncAndFetchOldWordArrayIOsyncAndFetchOldWordAddrIOsyncAndFetchOldIntArrayIOsyncAndFetchOldIntAddrIOsyncSubFetchNewWordArrayIOsyncSubFetchNewWordAddrIOsyncSubFetchNewIntArrayIOsyncSubFetchNewIntAddrIOsyncSubFetchOldWordArrayIOsyncSubFetchOldWordAddrIOsyncSubFetchOldIntArrayIOsyncSubFetchOldIntAddrIOsyncAddFetchNewWordArrayIOsyncAddFetchNewWordAddrIOsyncAddFetchNewIntArrayIOsyncAddFetchNewIntAddrIOsyncAddFetchOldWordArrayIOsyncAddFetchOldWordAddrIOsyncAddFetchOldIntArrayIOsyncAddFetchOldIntAddrIOsyncCasWordArrayIOsyncCasWordAddrIOsyncCasIntArrayIOsyncCasIntAddrIOsyncCasWordBoolArrayIOsyncCasWordBoolAddrIOsyncCasIntBoolArrayIOsyncCasIntBoolAddrIOsyncXorFetchNewWord32ArrayIOsyncXorFetchNewWord32AddrIOsyncXorFetchNewInt32ArrayIOsyncXorFetchNewInt32AddrIOsyncXorFetchOldWord32ArrayIOsyncXorFetchOldWord32AddrIOsyncXorFetchOldInt32ArrayIOsyncXorFetchOldInt32AddrIOsyncOrFetchNewWord32ArrayIOsyncOrFetchNewWord32AddrIOsyncOrFetchNewInt32ArrayIOsyncOrFetchNewInt32AddrIOsyncOrFetchOldWord32ArrayIOsyncOrFetchOldWord32AddrIOsyncOrFetchOldInt32ArrayIOsyncOrFetchOldInt32AddrIOsyncNandFetchNewWord32ArrayIOsyncNandFetchNewWord32AddrIOsyncNandFetchNewInt32ArrayIOsyncNandFetchNewInt32AddrIOsyncNandFetchOldWord32ArrayIOsyncNandFetchOldWord32AddrIOsyncNandFetchOldInt32ArrayIOsyncNandFetchOldInt32AddrIOsyncAndFetchNewWord32ArrayIOsyncAndFetchNewWord32AddrIOsyncAndFetchNewInt32ArrayIOsyncAndFetchNewInt32AddrIOsyncAndFetchOldWord32ArrayIOsyncAndFetchOldWord32AddrIOsyncAndFetchOldInt32ArrayIOsyncAndFetchOldInt32AddrIOsyncSubFetchNewWord32ArrayIOsyncSubFetchNewWord32AddrIOsyncSubFetchNewInt32ArrayIOsyncSubFetchNewInt32AddrIOsyncSubFetchOldWord32ArrayIOsyncSubFetchOldWord32AddrIOsyncSubFetchOldInt32ArrayIOsyncSubFetchOldInt32AddrIOsyncAddFetchNewWord32ArrayIOsyncAddFetchNewWord32AddrIOsyncAddFetchNewInt32ArrayIOsyncAddFetchNewInt32AddrIOsyncAddFetchOldWord32ArrayIOsyncAddFetchOldWord32AddrIOsyncAddFetchOldInt32ArrayIOsyncAddFetchOldInt32AddrIOsyncCasWord32ArrayIOsyncCasWord32AddrIOsyncCasInt32ArrayIOsyncCasInt32AddrIOsyncCasWord32BoolArrayIOsyncCasWord32BoolAddrIOsyncCasInt32BoolArrayIOsyncCasInt32BoolAddrIOsyncXorFetchNewWord16ArrayIOsyncXorFetchNewWord16AddrIOsyncXorFetchNewInt16ArrayIOsyncXorFetchNewInt16AddrIOsyncXorFetchOldWord16ArrayIOsyncXorFetchOldWord16AddrIOsyncXorFetchOldInt16ArrayIOsyncXorFetchOldInt16AddrIOsyncOrFetchNewWord16ArrayIOsyncOrFetchNewWord16AddrIOsyncOrFetchNewInt16ArrayIOsyncOrFetchNewInt16AddrIOsyncOrFetchOldWord16ArrayIOsyncOrFetchOldWord16AddrIOsyncOrFetchOldInt16ArrayIOsyncOrFetchOldInt16AddrIOsyncNandFetchNewWord16ArrayIOsyncNandFetchNewWord16AddrIOsyncNandFetchNewInt16ArrayIOsyncNandFetchNewInt16AddrIOsyncNandFetchOldWord16ArrayIOsyncNandFetchOldWord16AddrIOsyncNandFetchOldInt16ArrayIOsyncNandFetchOldInt16AddrIOsyncAndFetchNewWord16ArrayIOsyncAndFetchNewWord16AddrIOsyncAndFetchNewInt16ArrayIOsyncAndFetchNewInt16AddrIOsyncAndFetchOldWord16ArrayIOsyncAndFetchOldWord16AddrIOsyncAndFetchOldInt16ArrayIOsyncAndFetchOldInt16AddrIOsyncSubFetchNewWord16ArrayIOsyncSubFetchNewWord16AddrIOsyncSubFetchNewInt16ArrayIOsyncSubFetchNewInt16AddrIOsyncSubFetchOldWord16ArrayIOsyncSubFetchOldWord16AddrIOsyncSubFetchOldInt16ArrayIOsyncSubFetchOldInt16AddrIOsyncAddFetchNewWord16ArrayIOsyncAddFetchNewWord16AddrIOsyncAddFetchNewInt16ArrayIOsyncAddFetchNewInt16AddrIOsyncAddFetchOldWord16ArrayIOsyncAddFetchOldWord16AddrIOsyncAddFetchOldInt16ArrayIOsyncAddFetchOldInt16AddrIOsyncCasWord16ArrayIOsyncCasWord16AddrIOsyncCasInt16ArrayIOsyncCasInt16AddrIOsyncCasWord16BoolArrayIOsyncCasWord16BoolAddrIOsyncCasInt16BoolArrayIOsyncCasInt16BoolAddrIOsyncXorFetchNewWord8ArrayIOsyncXorFetchNewWord8AddrIOsyncXorFetchNewInt8ArrayIOsyncXorFetchNewInt8AddrIOsyncXorFetchOldWord8ArrayIOsyncXorFetchOldWord8AddrIOsyncXorFetchOldInt8ArrayIOsyncXorFetchOldInt8AddrIOsyncOrFetchNewWord8ArrayIOsyncOrFetchNewWord8AddrIOsyncOrFetchNewInt8ArrayIOsyncOrFetchNewInt8AddrIOsyncOrFetchOldWord8ArrayIOsyncOrFetchOldWord8AddrIOsyncOrFetchOldInt8ArrayIOsyncOrFetchOldInt8AddrIOsyncNandFetchNewWord8ArrayIOsyncNandFetchNewWord8AddrIOsyncNandFetchNewInt8ArrayIOsyncNandFetchNewInt8AddrIOsyncNandFetchOldWord8ArrayIOsyncNandFetchOldWord8AddrIOsyncNandFetchOldInt8ArrayIOsyncNandFetchOldInt8AddrIOsyncAndFetchNewWord8ArrayIOsyncAndFetchNewWord8AddrIOsyncAndFetchNewInt8ArrayIOsyncAndFetchNewInt8AddrIOsyncAndFetchOldWord8ArrayIOsyncAndFetchOldWord8AddrIOsyncAndFetchOldInt8ArrayIOsyncAndFetchOldInt8AddrIOsyncSubFetchNewWord8ArrayIOsyncSubFetchNewWord8AddrIOsyncSubFetchNewInt8ArrayIOsyncSubFetchNewInt8AddrIOsyncSubFetchOldWord8ArrayIOsyncSubFetchOldWord8AddrIOsyncSubFetchOldInt8ArrayIOsyncSubFetchOldInt8AddrIOsyncAddFetchNewWord8ArrayIOsyncAddFetchNewWord8AddrIOsyncAddFetchNewInt8ArrayIOsyncAddFetchNewInt8AddrIOsyncAddFetchOldWord8ArrayIOsyncAddFetchOldWord8AddrIOsyncAddFetchOldInt8ArrayIOsyncAddFetchOldInt8AddrIOsyncCasWord8ArrayIOsyncCasWord8AddrIOsyncCasInt8ArrayIOsyncCasInt8AddrIOsyncCasWord8BoolArrayIOsyncCasWord8BoolAddrIOsyncCasInt8BoolArrayIOsyncCasInt8BoolAddrIOsyncLockReleaseInt8AddrIOsyncLockReleaseInt8ArrayIOsyncLockTestSetInt8AddrIOsyncLockTestSetInt8ArrayIOsyncSynchronizeioCBoolToBoolBasesyncSynchronize#withMemBarrier#withMemBarrier_#atomicModifyMutVar_#atomicModifyMutVar2# memmoveMutableByteArrayFromAddr#memmoveMutableByteArrayToAddr#memmoveMutableByteArray# memmoveAddr#memsetWord64Addr#memsetWord64MutableByteArray#memsetInt64Addr#memsetInt64MutableByteArray#memsetWord32Addr#memsetWord32MutableByteArray#memsetInt32Addr#memsetInt32MutableByteArray#memsetWord16Addr#memsetWord16MutableByteArray#memsetInt16Addr#memsetInt16MutableByteArray#memsetWord8Addr#memsetWord8MutableByteArray#memsetInt8Addr#memsetInt8MutableByteArray#memcmpByteArrayAddr#memcmpByteArray#memcmpAddrByteArray# memcmpAddr#isSameMutableByteArray#isSameByteArray# toOrdering# fromOrdering#doubleToWord64#word64ToDouble#floatToWord32#word32ToFloat#unsafeThawByteArray#mutableByteArrayContents#unsafeThawArrayArray#unInt#unWord#PrimPrimBaseSizeOf Alignment toPrimBase fromPrimBasesizeOf# alignment#indexByteOffByteArray#indexByteArray# indexOffAddr#readByteOffMutableByteArray#readMutableByteArray# readOffAddr#writeByteOffMutableByteArray#writeMutableByteArray# writeOffAddr#setMutableByteArray# setOffAddr# bool2Int# int2Bool#setMutableByteArrayLoop#setOffAddrLoop#errorImpossible $fPrimMaybe$fPrim(,,,,,,,,)$fPrim(,,,,,,,)$fPrim(,,,,,,) $fPrim(,,,,,) $fPrim(,,,,) $fPrim(,,,) $fPrim(,,) $fPrim(,) $fPrimComplex $fPrimRatio$fPrimFingerprint $fPrimAny $fPrimAll $fPrimProduct $fPrimSum $fPrimDual $fPrimDown$fPrimGeneralCategory$fPrimNewlineMode $fPrimNewline$fPrimBufferMode $fPrimIOMode$fPrimThreadStatus$fPrimBlockReason$fPrimSeekMode$fPrimIODeviceType$fPrimOrdering $fPrimAlt$fPrimIdentity $fPrimCompose$fPrimProduct0$fPrimAp $fPrimCTimer $fPrimCKey $fPrimCId$fPrimCFsFilCnt$fPrimCFsBlkCnt$fPrimCClockId $fPrimCBlkCnt$fPrimCBlkSize $fPrim:~~: $fPrimConst $fPrimArg $fPrimLast $fPrimFirst $fPrimMin $fPrimMax $fPrimCRLim $fPrimCTcflag $fPrimCSpeed $fPrimCCc $fPrimCUid $fPrimCNlink $fPrimCGid $fPrimCSsize $fPrimCPid $fPrimCOff $fPrimCMode $fPrimCIno $fPrimCDev $fPrimErrno$fPrimFd $fPrimCDouble $fPrimCFloat$fPrimCUIntMax $fPrimCIntMax$fPrimCUIntPtr $fPrimCIntPtr$fPrimCSigAtomic $fPrimCWchar $fPrimCSize$fPrimCPtrdiff $fPrimCULLong $fPrimCLLong $fPrimCULong $fPrimCLong $fPrimCUInt $fPrimCInt $fPrimCUShort $fPrimCShort $fPrimCUChar $fPrimCSChar $fPrimCChar $fPrimCBool $fPrimWordPtr $fPrimIntPtr$fPrimStablePtr $fPrimFunPtr $fPrimPtr $fPrimChar $fPrimBool $fPrimDouble $fPrimFloat $fPrimWord64 $fPrimWord32 $fPrimWord16 $fPrimWord8 $fPrimWord $fPrimInt64 $fPrimInt32 $fPrimInt16 $fPrimInt8 $fPrimInt $fPrim:~:$fPrim() $fPrimEither AtomicBits"atomicAndFetchOldMutableByteArray#"atomicAndFetchNewMutableByteArray##atomicNandFetchOldMutableByteArray##atomicNandFetchNewMutableByteArray#!atomicOrFetchOldMutableByteArray#!atomicOrFetchNewMutableByteArray#"atomicXorFetchOldMutableByteArray#"atomicXorFetchNewMutableByteArray#atomicAndFetchOldOffAddr#atomicAndFetchNewOffAddr#atomicNandFetchOldOffAddr#atomicNandFetchNewOffAddr#atomicOrFetchOldOffAddr#atomicOrFetchNewOffAddr#atomicXorFetchOldOffAddr#atomicXorFetchNewOffAddr# AtomicCount"atomicAddFetchOldMutableByteArray#"atomicAddFetchNewMutableByteArray#"atomicSubFetchOldMutableByteArray#"atomicSubFetchNewMutableByteArray#atomicAddFetchOldOffAddr#atomicAddFetchNewOffAddr#atomicSubFetchOldOffAddr#atomicSubFetchNewOffAddr#AtomicatomicReadMutableByteArray#atomicWriteMutableByteArray#atomicReadOffAddr#atomicWriteOffAddr#casMutableByteArray# casOffAddr#casBoolMutableByteArray#casBoolOffAddr#atomicModifyMutableByteArray#atomicModifyOffAddr#!atomicBoolModifyMutableByteArray#)atomicBoolModifyFetchOldMutableByteArray#%atomicModifyFetchOldMutableByteArray#%atomicModifyFetchNewMutableByteArray#atomicModifyMutableByteArray_#atomicBoolModifyOffAddr#atomicModifyFetchOldOffAddr#atomicModifyFetchNewOffAddr#atomicModifyOffAddr_#"atomicNotFetchOldMutableByteArray#"atomicNotFetchNewMutableByteArray#atomicNotFetchOldOffAddr#atomicNotFetchNewOffAddr# $fAtomicAny $fAtomicAll$fAtomicProduct $fAtomicSum $fAtomicDual $fAtomicDown$fAtomicGeneralCategory$fAtomicNewlineMode$fAtomicNewline$fAtomicIOMode$fAtomicThreadStatus$fAtomicBlockReason$fAtomicSeekMode$fAtomicIODeviceType$fAtomicOrdering$fAtomicIdentity $fAtomicConst $fAtomicLast $fAtomicFirst $fAtomicMin $fAtomicMax $fAtomicErrno $fAtomicFd$fAtomicCUIntMax$fAtomicCIntMax$fAtomicCUIntPtr$fAtomicCIntPtr$fAtomicCSigAtomic$fAtomicCWchar $fAtomicCSize$fAtomicCPtrdiff$fAtomicCULong $fAtomicCLong $fAtomicCUInt $fAtomicCInt$fAtomicCUShort$fAtomicCShort$fAtomicCUChar$fAtomicCSChar $fAtomicCChar $fAtomicCBool$fAtomicWordPtr$fAtomicIntPtr$fAtomicFunPtr $fAtomicPtr $fAtomicChar $fAtomicBool$fAtomicCULLong$fAtomicCLLong$fAtomicWord64 $fAtomicInt64 $fAtomicWord$fAtomicWord32$fAtomicWord16 $fAtomicWord8 $fAtomicInt $fAtomicInt32 $fAtomicInt16 $fAtomicInt8$fAtomicCountProduct$fAtomicCountSum$fAtomicCountDual$fAtomicCountDown$fAtomicCountIdentity$fAtomicCountConst$fAtomicCountErrno$fAtomicCountFd$fAtomicCountCUIntMax$fAtomicCountCIntMax$fAtomicCountCUIntPtr$fAtomicCountCIntPtr$fAtomicCountCSigAtomic$fAtomicCountCWchar$fAtomicCountCSize$fAtomicCountCPtrdiff$fAtomicCountCULong$fAtomicCountCLong$fAtomicCountCUInt$fAtomicCountCInt$fAtomicCountCUShort$fAtomicCountCShort$fAtomicCountCUChar$fAtomicCountCSChar$fAtomicCountCChar$fAtomicCountCBool$fAtomicCountWordPtr$fAtomicCountIntPtr$fAtomicCountCULLong$fAtomicCountCLLong$fAtomicCountWord64$fAtomicCountInt64$fAtomicCountWord$fAtomicCountWord32$fAtomicCountWord16$fAtomicCountWord8$fAtomicCountInt$fAtomicCountInt32$fAtomicCountInt16$fAtomicCountInt8$fAtomicBitsIdentity$fAtomicBitsConst$fAtomicBitsFd$fAtomicBitsCUIntMax$fAtomicBitsCIntMax$fAtomicBitsCUIntPtr$fAtomicBitsCIntPtr$fAtomicBitsCSigAtomic$fAtomicBitsCWchar$fAtomicBitsCSize$fAtomicBitsCPtrdiff$fAtomicBitsCULong$fAtomicBitsCLong$fAtomicBitsCUInt$fAtomicBitsCInt$fAtomicBitsCUShort$fAtomicBitsCShort$fAtomicBitsCUChar$fAtomicBitsCSChar$fAtomicBitsCChar$fAtomicBitsCBool$fAtomicBitsWordPtr$fAtomicBitsIntPtr$fAtomicBitsBool$fAtomicBitsCULLong$fAtomicBitsCLLong$fAtomicBitsWord64$fAtomicBitsInt64$fAtomicBitsWord$fAtomicBitsWord32$fAtomicBitsWord16$fAtomicBitsWord8$fAtomicBitsInt$fAtomicBitsInt32$fAtomicBitsInt16$fAtomicBitsInt8AtomunAtom"acquireLockByteOffMutableByteArray"releaseLockByteOffMutableByteArrayacquireLockByteOffAddrreleaseLockByteOffAddrwithLockMutableByteArraywithLockOffAddr%atomicAddFetchOldMutableByteArrayNum#%atomicAddFetchNewMutableByteArrayNum#%atomicSubFetchOldMutableByteArrayNum#%atomicSubFetchNewMutableByteArrayNum#atomicAddFetchOldOffAddrNum#atomicAddFetchNewOffAddrNum#atomicSubFetchOldOffAddrNum#atomicSubFetchNewOffAddrNum#&atomicAndFetchOldMutableByteArrayBits#&atomicAndFetchNewMutableByteArrayBits#'atomicNandFetchOldMutableByteArrayBits#'atomicNandFetchNewMutableByteArrayBits#%atomicOrFetchOldMutableByteArrayBits#%atomicOrFetchNewMutableByteArrayBits#&atomicXorFetchOldMutableByteArrayBits#&atomicXorFetchNewMutableByteArrayBits#atomicAndFetchOldOffAddrBits#atomicAndFetchNewOffAddrBits#atomicNandFetchOldOffAddrBits#atomicNandFetchNewOffAddrBits#atomicOrFetchOldOffAddrBits#atomicOrFetchNewOffAddrBits#atomicXorFetchOldOffAddrBits#atomicXorFetchNewOffAddrBits#$fAtomicBitsAtom$fAtomicCountAtom $fAtomicAtom $fPrimAtom $fShowAtom$fEqAtom $fOrdAtom $fNumAtom $fEnumAtom$fIntegralAtom $fRealAtom$fRealFracAtom$fFractionalAtom$fFloatingAtom$fRealFloatAtom $fBitsAtom $fNFDataAtomOffunOffCountunCountSizeunSize byteCount byteCountTypebyteCountProxy alignment alignmentTypealignmentProxy unCountBytes# unCountBytes toByteCount countToOffcountToByteOffcountForProxyTypeOf countForType fromByteCountfromByteCountRemoffForProxyTypeOf offForType offToCountoffToByteCount toByteOff unOffBytes unOffBytes# fromByteOfffromByteOffRemprefetchValue0prefetchValue1prefetchValue2prefetchValue3 $fPrimCount $fPrimOff $fShowSize$fEqSize $fOrdSize $fNumSize $fRealSize$fIntegralSize $fBoundedSize $fEnumSize $fEqCount $fShowCount $fOrdCount $fEnumCount$fBoundedCount $fNumCount$fIntegralCount $fRealCount $fNFDataCount$fEqOff $fShowOff$fOrdOff $fEnumOff $fBoundedOff$fNumOff $fIntegralOff $fRealOff $fNFDataOff setOffPtr readOffPtrreadByteOffPtr writeOffPtrwriteByteOffPtrreadPtrwritePtrplusByteOffPtr plusOffPtrminusByteOffPtr minusOffPtrminusOffRemPtr copyPtrToPtrcopyByteOffPtrToPtr movePtrToPtrmoveByteOffPtrToPtrcomparePtrToPtrcompareByteOffPtrToPtr casOffPtratomicModifyOffPtratomicModifyOffPtr_atomicModifyFetchOldOffPtratomicModifyFetchNewOffPtratomicAddFetchOldOffPtratomicAddFetchNewOffPtratomicSubFetchOldOffPtratomicSubFetchNewOffPtratomicAndFetchOldOffPtratomicAndFetchNewOffPtratomicNandFetchOldOffPtratomicNandFetchNewOffPtratomicOrFetchOldOffPtratomicOrFetchNewOffPtratomicXorFetchOldOffPtratomicXorFetchNewOffPtratomicNotFetchOldOffPtratomicNotFetchNewOffPtr prefetchPtr0 prefetchPtr1 prefetchPtr2 prefetchPtr3prefetchOffPtr0prefetchOffPtr1prefetchOffPtr2prefetchOffPtr3freeHaskellFunPtr newStablePtrdeRefStablePtr freeStablePtr$fShowStablePtr$fNFDataStablePtrmkWeakNoFinalizermkWeakPtrNoFinalizer addCFinalizeraddCFinalizerEnv finalizeWeak GHC.TypesIOGHC.STST noDuplicateGHC.IOGHC.IO.ExceptionSomeAsyncExceptiondelay# waitRead#System.Posix.TypesFd waitWrite#fork#forkOn# killThread# ThreadKilledyield# myThreadId# GHC.Conc.SyncThreadId Control.MonadguardjoinMonad>>=>>returnfailFunctorfmapData.TraversablemapMsequencemfilter<$!>unless replicateM_ replicateMfoldM_foldM zipWithM_zipWithM mapAndUnzipMforever<=<>=>filterMforM Data.Foldablemsum sequence_forM_mapM_ Data.FunctorvoidapliftM5liftM4liftM3liftM2liftMwhen=<< MonadPlusmzeromplusatomicModifyMutVar#MutVar#augmentbuildseq realWorld#void# unsafeCoerce# nullAddr# GHC.MagiclazyoneShotrunRW# breakpointbreakpointCondinlineGHC.Exts groupWith magicDictcoerceIsListItemfromList fromListNtoListproxy# Data.StringIsString fromStringAddr#Array# ByteArray#Char#CharC#Double#DoubleD#Float#FloatF#Int#IntI#GHC.IntInt8I8#Int16I16#Int32#Int32I32#Int64#Int64I64#Weak# MutableArray#MutableByteArray#MVar# StablePtr#~~ ArrayArray#MutableArrayArray#State# StableName#Void#Word#WordW#GHC.WordWord8W8#Word16W16#Word32#Word32W32#Word64#Word64W64# ThreadId#BCO#TVar#Compact# Constraint RuntimeRepVecRepTupleRepSumRep LiftedRep UnliftedRepIntRepWordRepInt64Rep Word64RepAddrRepFloatRep DoubleRepVecCountVec2Vec4Vec8Vec16Vec32Vec64VecElem Int8ElemRep Int16ElemRep Int32ElemRep Int64ElemRep Word8ElemRep Word16ElemRep Word32ElemRep Word64ElemRep FloatElemRep DoubleElemRep CoercibleProxy# SmallArray#SmallMutableArray#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#gtChar#geChar#eqChar#neChar#ltChar#leChar#ord#+#-#*#mulIntMayOflo#quotInt#remInt# quotRemInt#andI#orI#xorI#notI# negateInt#addIntC#subIntC#>#>=#==#/=#<#<=#chr# int2Word# int2Float# int2Double# word2Float# word2Double#uncheckedIShiftL#uncheckedIShiftRA#uncheckedIShiftRL# plusWord# addWordC# subWordC# 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#pdep8#pdep16#pdep32#pdep64#pdep#pext8#pext16#pext32#pext64#pext#clz8#clz16#clz32#clz64#clz#ctz8#ctz16#ctz32#ctz64#ctz# byteSwap16# byteSwap32# byteSwap64# byteSwap# narrow8Int# narrow16Int# narrow32Int# narrow8Word# narrow16Word# narrow32Word#>##>=##==##/=##<##<=##+##-##*##/## negateDouble# fabsDouble# double2Int# double2Float# expDouble# logDouble# sqrtDouble# sinDouble# cosDouble# tanDouble# asinDouble# acosDouble# atanDouble# sinhDouble# coshDouble# tanhDouble#**##decodeDouble_2Int#decodeDouble_Int64#gtFloat#geFloat#eqFloat#neFloat#ltFloat#leFloat# plusFloat# minusFloat# timesFloat# divideFloat# negateFloat# fabsFloat# float2Int# expFloat# logFloat# sqrtFloat# sinFloat# cosFloat# tanFloat# asinFloat# acosFloat# atanFloat# sinhFloat# coshFloat# tanhFloat# powerFloat# float2Double#decodeFloat_Int# newArray#sameMutableArray# readArray# writeArray# sizeofArray#sizeofMutableArray# indexArray#unsafeFreezeArray#unsafeThawArray# copyArray#copyMutableArray# cloneArray#cloneMutableArray# freezeArray# thawArray# casArray#newSmallArray#sameSmallMutableArray#readSmallArray#writeSmallArray#sizeofSmallArray#sizeofSmallMutableArray#indexSmallArray#unsafeFreezeSmallArray#unsafeThawSmallArray#copySmallArray#copySmallMutableArray#cloneSmallArray#cloneSmallMutableArray#freezeSmallArray#thawSmallArray#casSmallArray# 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#newArrayArray#sameMutableArrayArray#unsafeFreezeArrayArray#sizeofArrayArray#sizeofMutableArrayArray#indexByteArrayArray#indexArrayArrayArray#readByteArrayArray#readMutableByteArrayArray#readArrayArrayArray#readMutableArrayArrayArray#writeByteArrayArray#writeMutableByteArrayArray#writeArrayArrayArray#writeMutableArrayArrayArray#copyArrayArray#copyMutableArrayArray# 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# newMutVar# readMutVar# writeMutVar# sameMutVar# casMutVar#catch#raise#raiseIO#maskAsyncExceptions#maskUninterruptible#unmaskAsyncExceptions#getMaskingState# atomically#retry# catchRetry# catchSTM#newTVar# readTVar# readTVarIO# writeTVar# sameTVar#newMVar# takeMVar# tryTakeMVar#putMVar# tryPutMVar# readMVar# tryReadMVar# sameMVar# isEmptyMVar# labelThread#isCurrentThreadBound# noDuplicate# threadStatus#mkWeak#mkWeakNoFinalizer#addCFinalizerToWeak# deRefWeak# finalizeWeak#touch#makeStablePtr#deRefStablePtr# eqStablePtr#makeStableName# eqStableName#stableNameToInt# compactNew#compactResize#compactContains#compactContainsAny#compactGetFirstBlock#compactGetNextBlock#compactAllocateBlock#compactFixupPointers# compactAdd#compactAddWithSharing# compactSize#reallyUnsafePtrEquality#par#spark#seq# getSpark# numSparks# dataToTag# tagToEnum# addrToAny# anyToAddr# mkApUpd0#newBCO#unpackClosure#getApStackVal# getCCSOf#getCurrentCCS# clearCCS# traceEvent# traceMarker#getThreadAllocationCounter#setThreadAllocationCounter#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#prefetchByteArray3#prefetchMutableByteArray3#prefetchAddr3#prefetchValue3#prefetchByteArray2#prefetchMutableByteArray2#prefetchAddr2#prefetchValue2#prefetchByteArray1#prefetchMutableByteArray1#prefetchAddr1#prefetchValue1#prefetchByteArray0#prefetchMutableByteArray0#prefetchAddr0#prefetchValue0#leInt64ltInt64geInt64gtInt64neInt64eqInt64leInt32ltInt32geInt32gtInt32neInt32eqInt32leInt16ltInt16geInt16gtInt16neInt16eqInt16leInt8ltInt8geInt8gtInt8neInt8eqInt8leWord64ltWord64geWord64gtWord64neWord64eqWord64leWord32ltWord32geWord32gtWord32neWord32eqWord32leWord16ltWord16geWord16gtWord16neWord16eqWord16leWord8ltWord8geWord8gtWord8neWord8eqWord8 GHC.ClasseseqWordneWordeqIntneIntgtIntgeIntltIntleIntgtWordgeWordltWordleWord traceEventsortWiththe maxTupleSizeSpecConstrAnnotation NoSpecConstrForceSpecConstrCDevCInoCModeCOffCPidCSsizeCGidCNlinkCUidCCcCSpeedCTcflagCRLimCBlkSizeCBlkCntCClockId CFsBlkCnt CFsFilCntCIdCKeyCTimer LinkCountUserIDGroupID ByteCount ClockTick EpochTimeDeviceIDFileIDFileMode ProcessID FileOffsetProcessGroupIDLimitData.OrdDownCCharCSCharCUCharCShortCUShortCIntCUIntCLongCULongCLLongCULLongCFloatCDoubleCPtrdiffCSizeCWchar CSigAtomicCClockCTime CUSeconds CSUSecondsCFileCFposCJmpBufCIntPtrCUIntPtrCIntMaxCUIntMaxuncheckedIShiftRA64#uncheckedIShiftL64# byteSwap64uncheckedShiftRL64#uncheckedShiftL64# byteSwap32 byteSwap16 GHC.Stack.CCScurrentCallStack iShiftRL# iShiftRA#iShiftL#shiftRL#shiftL#isTrue#atomicReadAtomMutableByteArrayatomicWriteAtomMutableByteArrayatomicReadAtomOffAddratomicWriteAtomOffAddr Semigroup<>sconcatstimesData.Semigroupoption mtimesDefaultdiffcycle1MingetMinMaxgetMaxArgArgMinArgMaxFirstgetFirstLastgetLast WrappedMonoid WrapMonoid unwrapMonoidOption getOption stimesMonoidstimesIdempotentstimesIdempotentMonoidGHC.Num+-