!      !"#$%&'()*+,-./0123456789:;<=>? @ A B C D E F GHIJKLMNOPQRSTUV W X Y Z [ \ ] ^ _ ` a b c d e f g h i jklmnopqrstuvwxyz{|}~       !"#$%&'()*+,-./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-portableNoneFHV@Vprimal5A 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.WprimalPThrow 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 eVWVW(c) Alexey Kuleshevich 2020BSD3(Alexey Kuleshevich <alexey@kuleshevi.ch> experimental non-portableNone =>?@ACFSXKv kprimalConstruct a primitive actionoprimalUnwrap a primitive actionpprimal"A shorter synonym for the magical sprimal;Construct a primitive action that does not return anything.tprimalLift an  action to j with the + state token. Type restricted synonym for vuprimalLift an  action to j9 with the same state token. Type restricted synonym for vvprimalLift an action from the n to another j with the same state token.wprimal Restrict a n action that works with  to .xprimal Restrict a n action that works in .jklmnopqrstuvwx(c) Alexey Kuleshevich 2020BSD3(Alexey Kuleshevich <alexey@kuleshevi.ch> experimental non-portableNone>FXsyprimal Unwrap any n& action while coercing the state tokenHighly unsafe!zprimal Unwrap any nF action that does not return anything, while coercing the state tokenHighly unsafe!{primal Convert a n action to another j while coercing the state token.Highly unsafe!|primal Convert a n action to  while coercing the state token s.Highly unsafe!}primal Convert a n action to # while coercing the state token to .Highly unsafe!~primal Convert an  action to some j while coercing the state token.Highly unsafe!It is similar to ,, except resulting action can be any other j. action, therefore it is a lot more dangerous.primal Convert an  action to some j while coercing the state token.Highly unsafe!primalSame as , except works in any j.primalSame as T, except works not only with , but with other n# 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 U and 6.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 nL action and compute it as a pure value, while inlining the action. Same as , but applied to any n action.Ridiculously unsafe!primalSame as S, except works in any nprimalSame as 6, except works in any nprimal A version of v that coerce the state token.Highly unsafe!6STUyz{|}~yz{}|~UTS6 (c) Alexey Kuleshevich 2020BSD3(Alexey Kuleshevich <alexey@kuleshevi.ch> experimental non-portableNone>FSX{primalThis is the same as W, but restricted to jprimalSame as , but generalized to jprimal 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.VW (c) Alexey Kuleshevich 2020BSD3(Alexey Kuleshevich <alexey@kuleshevi.ch> experimental non-portableNone >FSX 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>FSXgprimalnThis 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 jprimalPForward 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-portableNone0primal2Helper function that converts a type into a string?     jklmnopqrstuvwxpjknolmsrqtuvwx(c) Alexey Kuleshevich 2020BSD3(Alexey Kuleshevich <alexey@kuleshevi.ch> experimental non-portableNone>FprimalMakes 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 :  and is generalized to jprimalOrphan instance defined in Data.Prim.StableName78:9:987(c) Alexey Kuleshevich 2020BSD3(Alexey Kuleshevich <alexey@kuleshevi.ch> experimental non-portableNone FM2>=(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 Fjprimal@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  !"#$%&'()*+,-./012>=(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 arraysprimal&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  !"#$%&'()*+,-./012>=      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~(c) Alexey Kuleshevich 2020BSD3(Alexey Kuleshevich <alexey@kuleshevi.ch> experimental non-portableNone FprimalCast a Double into a 64bit WordprimalCast a 64bit Word into a DoubleprimalCast a Float into a 32bit WordprimalCast a 32bit Word into a Float(c) Alexey Kuleshevich 2020BSD3(Alexey Kuleshevich <alexey@kuleshevi.ch> experimental non-portableNoneF !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{ |}~ !"#$%&'()*+,-./012      !"#$%&'()*+,-./0123456789:;<=>?@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 { | } ~        !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~x$ % & ) ' (*+,- .!/"0#1>=2      !"#$%&'()*+,-./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 >, V, 56 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 ?@ABDCFE           DCBAFE@?(c) Alexey Kuleshevich 2020BSD3(Alexey Kuleshevich <alexey@kuleshevi.ch> experimental non-portableNone18=>?FHMVXu; primalRead an element from L) atomically. Implies full memory barrier.primalWrite an element into L) 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 L@. 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 L@. This is essentially an implementation of a spinlock using CAS.primalUsing 1 perform atomic modification of an element in a L. Returns the previous value.primalUsing 1 perform atomic modification of an element in a L. Returns the previous value.primalUsing 1 perform atomic modification of an element in a L. Returns the new value.primalUsing 1 perform atomic modification of an element in a L.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 architecturesprimal%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 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 Lprimal0Function 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 Lprimal0Function to be applied atomically to the elementprimalStarting stateprimalArray to be mutatedprimalIndex in number of = elements into the Lprimal0Function to be applied atomically to the elementprimalStarting stateprimalArray to be mutatedprimalIndex in number of = elements into the Lprimal0Function to be applied atomically to the elementprimalStarting stateprimalArray to be mutatedprimalIndex in number of = elements into the Lprimal0Function to be applied atomically to the elementprimalStarting stateprimalArray to be mutatedprimalIndex in number of = elements into the Lprimal0Function 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 state2{|}~2{|}~(c) Alexey Kuleshevich 2020BSD3(Alexey Kuleshevich <alexey@kuleshevi.ch> experimental non-portableNone.1=>?FHMUVX primalAtomic reads on 4 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 1 with offset primalSame as   , but for 1 with offset!456789:;<=>?@ABCDEFGHIJKLMNOPQRST!456789:;<=>?@ABCDEFGHIJKLMNOPQRST(c) Alexey Kuleshevich 2020BSD3(Alexey Kuleshevich <alexey@kuleshevi.ch> experimental non-portableNone FHMVXfprimalOffset in number of elementsiprimalNumber of elementsoprimalBGet the size of the data type in bytes. Argument is not evaluated.pprimalSame as sizeOf?, except that the type can be supplied as a type level argument:set -XTypeApplicationsimport Data.PrimbyteCountType @Int64Count {unCount = 8}qprimalSame as sizeOf, but argument is a < of a, instead of the type itself.import Data.Primimport Data.Proxy%byteCountProxy (Proxy :: Proxy Int64)Count {unCount = 8}rprimalBGet the alignemnt of the type in bytes. Argument is not evaluated.sprimalSame as r,, except that the type can be supplied with TypeApplications:set -XTypeApplicationsimport Data.PrimalignmentType @Int324tprimalSame as r, but argument is a < of a, instead of the type itself.import Data.Proxy%alignmentProxy (Proxy :: Proxy Int64)8vprimal Covert to number of bytes as an >wprimalCovert to the i of bytesxprimal$Helper noop function that restricts i to the type of proxy{primal$Helper noop function that restricts fset to the type of proxy|primal&Compute byte offset from an offset of  typetoByteOff (10 :: Off Word64)Off {unOff = 80}}primal0Convert offset of some type into number of bytes_( >@BEHVXZ]`3 <; jp{456fghijklmnopqrstuvwxyz{|}~-456{jpopqrstlmnijkvwuyzxfgh|}~{3<;(c) Alexey Kuleshevich 2020BSD3(Alexey Kuleshevich <alexey@kuleshevi.ch> experimental non-portableNone>FprimalcFind 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 valueCde?@ABDCFEIJKLMNOPQAIJKLMNOPQDCBAFE@?(c) Alexey Kuleshevich 2020BSD3(Alexey Kuleshevich <alexey@kuleshevi.ch> experimental non-portableNone>`primalSame as  , but generalized to jprimalSame as  , but generalized to jprimalSame as  , but generalized to j4GH4HG(c) Alexey Kuleshevich 2020BSD3(Alexey Kuleshevich <alexey@kuleshevi.ch> experimental non-portableNone>F 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 R5 R5 *+,-./*01*23*24-.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*cd*01*ef*gh*ij*ik*il*il*mn*mn*op*op*qr*qs*qt*qu*qv*qv*qw*qw*0x*0y*2z*2{*2|*2}*2~*2*2*2*2*ef*g*g*g          !"#$%&'()*+,-./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[\]^_`abccdefghijklmnopqrstuvwxyz{|}~%&'(-**g**  -. -. * -.-.-.-.* -.-.******** *!*"*#$*#%*&*'*(*)***+*,*-*.*/*0*1*2*3*#4*56*57*58*59*:;*<*=*>*?*@*A*B*C*D*E*F-G-.H-.I*J*K-.L-.M-.N-.O-.P-QR-QS-QT*U*V-QW*XY-.Z-.[*X\*X]*X^*X_*X`-.a*bc*bd-.e-.f-.g-.h-i-j-.k-l-m-.n-o-p-.q-r-s*tu*tv*tw*tx-.y*tz*t{-.|*t}*t~-.-.-.-.-.--.-.-.-.-.-.--****-.**-.**-.-.*23*24-.-.----------------------------------.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-. -. -. -. -. -.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-. -.!-."-.#-.$-.%-.&-.'-.(-.)-.*-.+-.,-.--..-./-.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-.{-.|-.}-.~-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-. -. -. -. -. -.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-. -.!-."-.#-.$-.%-.&-.'-.(-.)-.*-.+-.,-.--..-./-.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-.{-.|-.}-.~-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-. -. -. -. -. -.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-. -.!-."-.#-.$-.%-.&-.'-.(-.)-.*-.+-.,-.--..-./-.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-.{-.|-.}-.~-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-. -. -. -. -. -.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-. -.!-."-.#-.$-.%-.&-.'-.(-.)-.*-.+-.,-.--..-./-.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-.{-.|-.}-.~-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-. -. -. -. -. -. -. -. -. -. -. *t *t *t *t *t *t *t *t *t *t *t *t *t *t *t *t *t *t *t *t *t *t *t !*t "* #* $* %* &* '* (* )* ** +* ,* -* .* /* 0* 1* 2* 3* 4* 5* 6* 7* 8* 9* :- ; <- ; =- ; >- ; ?- ; @- ; A- ; B- ; C- ; D- ; E- ; F- ; G*X H*X I*X J*X K*X L*X M*X 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*  [*  [*  \*  \*  ]*  ]*  ^*  ^*  _*  _*  `*  `*  a*  a*  b*  b*  c*  c* *  d*  e*  f*  g*  h*  i*  j*  k*  l*  m*  n*  o*  p* q r* q r*o s*o s*o t*o t*o u*o u*o v*o v*o w*o w*o x*o x*o y*o y*o z*o z*o {*o {*o |*o |*o }*o }*o ~*o ~*o *o *o *o *o *o *o *o *o *o *o *o *o *o *o *o *o *o *o *o *o *o *o *o *o *o *o *o *o *t *t * * * * * * * * * * * -     * * * * * *  *  * *  *  * *  *  * *  *  * *  *  * *  *  * * G* G* *  *  * *  *  * *  *  * * * *q*0*0*0 %primal-0.1.0.0-3ITPPqWabZnLbM7R5UMiTJ 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 deRefWeakfinalizebaseData.Typeable.InternalTypeableghc-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.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 fromCount# fromCount toByteCount countAsProxy fromByteCountfromByteCountRem offAsProxy toByteOfffromOff# 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.MonadguardGHC.BasejoinMonad>>=>>returnfailFunctorfmapData.TraversablemapMsequencemfilter<$!>unless replicateM_ replicateMfoldM_foldM zipWithM_zipWithM mapAndUnzipMforever<=<>=>filterMforM Data.Foldablemsum sequence_forM_mapM_ Data.FunctorvoidapliftM5liftM4liftM3liftM2liftMwhen=<< MonadPlusmzeromplusAnyatomicModifyMutVar#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<>Monoidmemptymappendmconcat Data.MonoidFirstgetFirstLastgetLastApgetApData.Semigroup.InternalDualgetDualEndoappEndoAllgetAllgetAnySumgetSumProduct getProductAltgetAltGHC.Num+-