нУЁh$ChШy▓ !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~─│┌┐└┘├┤┬┴┼▀▄█▌▐░▒▓⌠■∙√≈≤≥ ⌡°²·÷═║╒ёє╔ії╗╘╙╚╛ґў╞╟╠╡ЁЄ╣ІЇ╦╧╨╩╪ҐЎ©юабцдефгхийклмнопярстужвьызшэщчъЮАБЦДЕФГХИЙКЛМНОПЯРСТУЖВЬЫЗШЭЩЧЪ─│┌┐└┘├┤┬┴┼▀▄█▌▐░▒▓⌠■∙√≈≤≥ ⌡°²·÷═║╒ёє╔ії╗╘╙╚╛ґў╞╟╠╡ЁЄ╣ІЇ╦╧╨╩╪ҐЎ©юабцдефгхийклмнопярстужвьызшэщчъЮАБЦДЕФГХИЙКЛМНОПЯРСТУЖВЬЫЗШЭЩЧЪ─│┌┐└┘├┤┬┴┼▀▄█▌▐░▒▓⌠■∙√≈≤≥ ⌡°²·÷═║╒ёє╔ії╗╘╙╚╛ґў╞╟╠╡ЁЄ╣ІЇ╦╧╨╩╪ҐЎ©юабцдефгхийклмнопярстужвьызшэщчъЮАБЦДЕФГХИЙКЛМНОПЯРСТУЖВЬЫЗШЭЩЧЪ─│┌┐└┘├┤┬┴┼▀▄█▌▐░▒▓⌠■∙√≈≤≥ ⌡°²·÷═║╒ёє╔ії╗╘╙╚╛ґў╞╟╠╡ЁЄ╣ІЇ╦╧╨╩╪ҐЎ©юабцдефгхийклмнопярстужвьызшэщчъЮАБЦДЕФГХИЙКЛМНОПЯРСТУЖВЬЫЗШЭЩЧЪ─│┌┐└┘├┤┬┴┼▀▄█▌▐░▒▓⌠■∙√≈≤≥ ⌡°²·÷═║╒ёє╔ії╗╘╙╚╛ґў╞╟╠╡ЁЄ╣ІЇ╦╧╨╩╪ҐЎ©юабцдефгхийклмнопярстужвьызшэщчъЮАБЦДЕФГХИЙКЛМНОПЯРСТУЖВЬЫЗШЭЩЧЪ─│┌┐└┘├┤┬┴┼▀▄█▌▐░▒▓⌠■∙√≈≤≥ ⌡°²·÷═║╒ёє╔ії╗╘╙╚╛ґў╞╟╠╡ЁЄ╣ІЇ╦╧╨╩╪ҐЎ©юабцдефгхийклмнопярстужвьызшэщчъЮАБЦДЕФГХИЙКЛМНОПЯРСТУЖВЬЫЗШЭЩЧЪ─│┌┐└┘├┤┬┴┼▀▄█▌▐░▒▓⌠■∙√≈≤≥ ⌡°²·÷═║╒ёє╔ії╗╘╙╚╛ґў╞╟╠╡ЁЄ╣ІЇ╦╧╨╩╪ҐЎ©юабцдефгхийклмнопярстужвьызшэщчъЮАБЦДЕФГХИЙКЛМНОПЯРСТУЖВЬЫЗШЭЩЧЪ─│┌┐└┘├┤┬┴┼▀▄█▌▐░▒▓⌠■∙√≈≤≥ ⌡°²·÷═║╒ёє╔ії╗╘╙╚╛ґў╞╟╠╡ЁЄ╣ІЇ╦╧╨╩╪ҐЎ©юабцдефгхийклмнопярстужвьызшэщчъЮАБЦДЕФГХИЙКЛМНОПЯРСТУЖВЬЫЗШЭЩЧЪ─ │ ┌ ┐ └ ┘ ├ ┤ ┬ ┴ ┼ ▀ ▄ █ ▌ ▐ ░ ▒ ▓ ⌠ ■ ∙ √ ≈ ≤ ≥ ⌡ ° ² · ÷ ═ ║ ╒ ё є ╔ і ї ╗ ╘ ╙ ╚ ╛ ґ ў ╞ ╟ ╠ ╡ Ё Є ╣ І Ї ╦ ╧ ╨ ╩ ╪ Ґ Ў © ю а б ц д е ф г х и й к л м н о п я р с т у ж в ь ы з ш э щ ч ъ Ю А Б Ц Д Е Ф Г Х И Й К Л М Н О П Я Р С Т У Ж В Ь Ы З Ш Э Щ Ч Ъ ─ │ ┌ ┐ └ ┘ ├ ┤ ┬ ┴ ┼ ▀ ▄ █ ▌ ▐ ░ ▒ ▓ ⌠ ■ ∙ √ ≈ ≤ ≥ ⌡ ° ² · ÷ ═ ║ ╒ ё є ╔ і ї ╗ ╘ ╙ ╚ ╛ ґ ў ╞ ╟ ╠ ╡ Ё Є ╣ І Ї ╦ ╧ ╨ ╩ ╪ Ґ Ў © ю а б ц д е ф г х и й к л м н о п я р с т у ж в ь ы з ш э щ ч ъ Ю А Б Ц Д Е Ф Г Х И Й К Л М Н О П Я Р С Т У Ж В Ь Ы З Ш Э Щ Ч Ъ ─│┌┐└┘├┤┬┴┼▀▄█▌▐░▒▓⌠■∙√≈≤≥ ⌡°²·÷═║╒ёє╔ії╗╘╙╚╛ґ ў ╞ ╟ ╠ ╡ Ё Є ╣ІЇ╦╧╨ ╩ ╪ Ґ Ў © ю а б цдефгхийклмнопярстужвьызшэщчъЮАБЦ Д Е Ф Г Х И Й К Л М Н О П Я Р С Т У Ж В Ь ЫЗШЭЩЧЪ─│┌┐└┘├┤┬┴┼▀▄█▌▐░▒▓⌠■∙√≈≤≥ ⌡°²·÷═║╒ёє╔ії╗╘╙╚╛ґў╞╟╠╡ЁЄ╣ІЇ╦╧╨╩╪ҐЎ©юабцдефгхийклмнопярстужвьызшэщчъЮАБЦДЕФГХИЙКЛМНОПЯРСТУЖВЬЫЗШЭЩЧЪ─ │ ┌ ┐ └ ┘ ├ ┤ ┬ ┴ ┼ ▀ ▄ █ ▌ ▐ ░ ▒ ▓ ⌠ ■ ∙ √ ≈ ≤ ≥ ⌡ ° ² · ÷ ═ ║ ╒ ё є ╔ і ї ╗ ╘ ╙ ╚ ╛ ґ ў ╞ ╟ ╠ ╡ Ё Є ╣ І Ї ╦ ╧ ╨ ╩ ╪ Ґ Ў © ю а б ц д е ф г х и й к л м н о п я р с т у ж в ь ы з ш э щ ч ъ Ю А Б Ц Д Е Ф Г Х И Й К Л М Н О П Я Р С Т У Ж В Ь Ы З Ш Э Щ Ч Ъ ─│┌┐└┘├┤┬┴┼▀▄█▌▐░▒▓⌠■∙√≈≤≥ ⌡°²·÷═║╒ёє╔ії╗╘╙╚╛ґў╞╟╠╡ЁЄ╣ІЇ╦╧╨╩╪ҐЎ©юабцдефгхийклмнопярстужвьызшэщчъЮАБЦДЕФГХИЙКЛМНОПЯРСТУЖВЬЫЗШЭЩЧЪ─│┌┐└┘├┤┬┴┼▀▄█▌▐░▒▓⌠■∙√≈≤≥ ⌡°²·÷═║╒ёє╔ії╗╘╙╚╛ґў╞╟╠╡ЁЄ╣ІЇ╦╧╨╩╪ҐЎ©юаб ц д е ф г х и й к л м н о п я р с т у ж в ь ы з ш э щ ч ъ Ю А Б Ц Д Е Ф Г Х И Й К Л М Н О П Я Р С Т У Ж В Ь Ы З Ш Э Щ Ч Ъ ─ │ ┌ ┐ └ ┘ ├ ┤ ┬ ┴ ┼ ▀ ▄ █ ▌ ▐ ░ ▒ ▓ ⌠ ■ ∙ √ ≈ ≤ ≥ ⌡ ° ² · ÷ ═ ║ ╒ ё є ╔ і ї ╗ ╘ ╙ ╚ ╛ ґ ў ╞ ╟ ╠ ╡ Ё Є ╣ І Ї ╦ ╧ ╨ ╩ ╪ Ґ Ў © ю а б ц д е ф гхийклмнопярстужвьызшэщчъЮАБЦДЕФГХИЙКЛМНОПЯРСТУЖВЬЫЗШЭЩЧЪ─│┌┐└┘├┤┬┴┼▀▄█▌▐░▒▓⌠■∙√≈≤≥ ⌡°²·÷═║╒ёє╔ії╗╘╙╚╛ґў╞╟╠╡ЁЄ╣ІЇ╦╧╨╩╪ҐЎ©юабцдефгхийклмнопярстужвьызшэщчъЮАБЦДЕФГХИЙКЛМНОПЯРСТУЖВЬЫЗШЭЩЧЪ─│┌┐└┘├┤┬┴┼▀▄█▌▐░▒▓⌠■∙√≈≤≥ ⌡°²·÷═║╒ёє╔ії╗╘╙╚╛ґў╞╟╠╡ЁЄ╣ІЇ╦╧╨╩╪ҐЎ©юабцдефгхийклмнопярстужвьызшэщчъЮАБЦДЕФГХИЙКЛМНОПЯРСТУЖВЬЫЗШЭЩЧЪ─│┌┐└┘├┤┬┴┼▀▄█▌▐░▒▓⌠■∙√≈≤≥ ⌡°²·÷═║╒ёє╔ії╗╘╙╚╛ґў╞╟╠╡ЁЄ╣ІЇ╦╧╨╩╪ҐЎ©юабцдефгхийклмнопярстужвьызшэщчъЮАБЦДЕФГХИЙКЛМНОПЯРСТУЖВЬЫЗШЭЩЧЪ─│┌┐└┘├┤┬┴┼▀▄█▌▐░▒▓⌠■∙√≈≤≥ ⌡°²·÷ ═ ║ ╒ ё є ╔ і ї ╗ ╘ ╙ ╚ ╛ ґ ў ╞ ╟ ╠ ╡ Ё Є ╣ І Ї ╦ ╧ ╨ ╩ ╪ Ґ Ў © ю а б ц д е ф г х и й к л мнопярстужвьызшэщчъЮАБЦДЕФГХИЙКЛМНОПЯРСТУЖВЬЫЗШЭЩЧЪ─│┌┐└┘├┤┬┴┼▀▄█▌▐░▒ (c) Alexey Kuleshevich 2020BSD3(Alexey Kuleshevich experimentalnon-portableNoneгив8▌Цprimal5A class for monads in which exceptions may be thrown.(Instances should obey the following law:throwM e >> x = throwM eзIn other words, throwing an exception short-circuits the rest of the monadic computation.NoteThis is an identical class to ыhttps://hackage.haskell.org/package/exceptions/docs/Control-Monad-Catch.html#t:MonadThrow MonadThrow from exceptionsЯ package. The reason why it was copied, instead of a direct dependency on the aforementioned package is because MonadCatch and MonadMask└ are not right abstractions for exception handling in presence of concurrency and also because instances for such transformers as ▓ and ⌠ are flawed.ДprimalпThrow 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.Prim.Exception's .ЦДЦД(c) Alexey Kuleshevich 2020BSD3(Alexey Kuleshevich experimentalnon-portableNone->?юабдгитвыexperimentalnon-portableNone?гитыEw ▒primal2Bogus Normal Form. This is useful in places where Б© constraint is required, but an instance can't really be created in any meaningful way for the type at hand. Creating environment in benchmarks is one such place where it may come in handy.⌠primalSame as !, except it is not restricted to / state token.■primalНThis is an action that ensures that the value is still available and garbage collector has not cleaned it up.пMake 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 withAlivePrimBase or √ instead.∙primalпForward compatible operator that might be introduced in some future ghc version.See: 1https://gitlab.haskell.org/ghc/ghc/-/issues/17760#17760╠Current 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.√primalSimilar to ■. See withAlive# for more info.≈primalкAn action that evaluates a value to Weak Head Normal Form (WHNF). Same as , except it works in Ъ3. This function provides stronger guarantees than ж with respect to ordering of operations, but it does have a slightly higher overhead.≤primalRun the action and then use ≈ц to ensure its result is evaluated to Weak Head Normal Form (WHNF)≥primalГAn action that evaluates a value to Normal Form (NF). This function provides stronger guarantees than ■( with respect to ordering of operations. primalRun the action and the using ≥4 ensure its result is evaluated to Normal Form (NF)⌡primal:Unlawful instance that only evaluates its contents to WHNF∙primalThe value to preserveprimal5The continuation in which the value will be preserved√primalThe value to preserveprimal2Action to run in which the value will be preserved∙√≈≤≥ ■Б⌡°²·÷▒▓⌠■∙√≈≤≥ ■⌠√∙≈≤≥ ▒▓(c) Alexey Kuleshevich 2020BSD3(Alexey Kuleshevich experimentalnon-portableNoneG,°primalSimilar to ═р, but condional is supplied in a form of monadic action rather than a pure value.²primalSimilar to ║р, but condional is supplied in a form of monadic action rather than a pure value.о╒ёє╔ії╗╘╙╚╛ґў/й ╞╟║╠╡ЁЄ╣ІЇ╦╧╨╩╪ҐЎ©юиаубцдефг═хийкБЫЗШЧЭЩЪ─│┌┐└┘├┤┬┴┼▀▄█▌▐░≈≤≥ °²#┐/┌Ъ─ЫЗ│ШЭЩЧй у░▌▐и┬┤┘├└┴┼▀▄█≈≤Б≥ °²(c) Alexey Kuleshevich 2020BSD3(Alexey Kuleshevich experimentalnon-portableNone?гыTA·primalexperimentalnon-portableNone?гтыЮa°╠primalThis is the same as throwIO, but works with any Ъ without restriction on /.╡primal┐Raise an impure exception from pure code. Returns a thunk, which will result in a supplied exceptionn being thrown when evaluated.ЁprimalSimilar to Ё;, except that it wraps any known non-async exception with SomeAsyncExceptionг. This is necessary, because receiving thread will get the exception in an asynchronous manner and without proper wrapping it will not be able to distinguish it from a regular synchronous exceptionЄprimalBehaves exactly as Є, except that it works in any Ш.╪primalЯRun an action, while invoking an exception handler if that action fails for some reason. Exception handling function has async exceptions masked, but it is still interruptible, which can be undesired in some scenarios. If you are sure that the cleanup action does not deadlock and you do need hard guarantees that it gets executed you can run it as uninterruptible:хuninterruptibleMask $ \restore -> withException (restore action) handlerҐprimalSame as ╪а, but will invoke exception handling function on all exceptions.ЎprimalAsync safe version of .гprimalїMask all asychronous exceptions, but keep it interruptible, unless the inherited state was uninterruptible already, in which case this action has no affect. Same as , except that it is polymorphic in state token. Inside a state thread it cannot affect the result of computation, therefore it is safe to use it within й monad.иprimalїMask all asychronous exceptions, but keep it interruptible, unless the inherited state was uninterruptible already, in which case this action has no affect. Same as , except that it is polymorphic in state token. Inside a state thread it cannot affect the result of computation, therefore it is safe to use it within й monad.йprimalфMask all asychronous exceptions and mark it uninterruptible. Same as , except that it is polymorphic in state token. Inside a state thread it cannot affect the result of computation, therefore it is safe to use it within й monad.кprimal≥Mask all async exceptions and make sure evaluation cannot be interrupted. It is polymorphic in the state token because it is perfectly safe to use with й р actions that don't perform any allocations. It doesn't have to be restricted to /щ because it has no impact on other threads and can't affect the result of computation, moreover pure functions that implement tight loops are already non-interruptible. In fact using this function is more dangerous in 8 than it is in й ю, because misuse can lead to deadlocks in a concurrent setting.мprimalA direct wrapper around И4 primop. This is different and more dangerous than г> because it can turn uninterrubtable state into interruptable.нprimalA direct wrapper around К primop.оprimalA direct wrapper around Й primop.пprimalSame as м, but generalized to Ъ╟╒ёє╔ії╗╘╙╚╛ґў/Oй ╞╟║╠╡ЁЄ╣ІЇ╦╧╨╩╪э ч щ Ю ъ Ц Д Ф Е Х Г Й И Л К Н М П О У Т С Р Я Ь В Ж Э Ш З Ы Щ Ч Ъ ┌─│├┘└┐█▀▄┼┴┬┤ҐЎ©юиаубцдефг═хийкжвъtчщэшзыьЮБЦДЫЗШЧЭЩЪ─│┌┐└┘├┤┬┴┼▀▄█▌▐░≈≤≥ °²╞╟╠╡ЁЄ╣ІЇ╦╧╨╩╪ҐЎ©юабцдефгхийклмнопЮ╠Ё╡Є╣ІЇ╦╧╨╩Ў╪Ґа©бюфцдеигхйклмноЭ Ш З Ы п├┘└┐ЮУ Т С Р Я П О ╞╟Д Ц ┌─│─█▀▄┼┴┬┤Ь В Ж Н М Щ ч щ Ю ъ Ф Е Х Г Л К Й И Oвэ жЧ ъtчщэшзыьЪ (c) Alexey Kuleshevich 2020BSD3(Alexey Kuleshevich experimentalnon-portableNone?гивыI$яprimalexperimentalnon-portableNone?г│ЙЖprimalMakes a ш ь for an arbitrary object. The object passed as the first argument is not evaluated by Ж.ВprimalSimilar to жhttp://hackage.haskell.org/package/stable-maps/docs/System-Mem-StableName-Dynamic.htmlmakeDynamicStableName, but returns ш L and is generalized to ЪЬprimalOrphan instance defined in Data.Prim.StableNameь ы ш з ЖВш з ЖВы ь 2(c) Alexey Kuleshevich 2020BSD3(Alexey Kuleshevich experimentalnon-portableNoneгн┌┼÷═╗┐╛╚3(c) Alexey Kuleshevich 2020BSD3(Alexey Kuleshevich experimentalnon-portableNone>югы┐В√primal1Helper function for converting casBool IO actions≈primal,https://en.wikipedia.org/wiki/Memory_barrierMemory barrierф. This will ensure that the cache is fully updated before continuing.║ЫЗШЭЩЧЪ─ │ ┌ ┐ └ ┘ ├ ┤ ┬ ┴ ┼ ▀ ▄ █ ▌ ▐ ░ ▒ ▓ ⌠ ■ ∙ √ ≈ ≤ ≥ ⌡ ° ² · ÷ ═ ║ ╒ ё є ╔ і ї ╗ ╘ ╙ ╚ ╛ ґ ў ╞ ╟ ╠ ╡ Ё Є ╣ І Ї ╦ ╧ ╨ ╩ ╪ Ґ Ў © ю а б ц д е ф г х и й к л м н о п я р с т у ж в ь ы з ш э щ ч ъ Ю А Б Ц Д Е Ф Г Х И Й К Л М Н О П Я Р С Т У Ж В Ь Ы З Ш Э Щ Ч Ъ ─│┌┐└┘├┤┬┴┼▀▄█▌▐░▒▓⌠■∙√≈≤≥ ⌡°²·÷═║╒ёє╔ії╗╘╙╚╛ґў╞╟╠╡ЁЄ╣ІЇ╦╧╨╩╪ҐЎ©юабцдефгхийклмнопярстужвьызшэщчъЮАБЦДЕФГХИЙКЛМНОПЯРСТУЖВЬЫЗШЭЩЧЪ─│┌┐└┘├┤┬┴┼▀▄█▌▐░▒▓⌠■∙√≈≤≥4(c) Alexey Kuleshevich 2020BSD3(Alexey Kuleshevich experimentalnon-portableNoneг├а2÷═╗╧╨╩╪ҐЎ©юабцдефвьызшэщчъЮАБЦДУЖВЬЫЗШЭЩЧЪ─│┌┐ЦД╛╚5(c) Alexey Kuleshevich 2020BSD3(Alexey Kuleshevich experimentalnon-portableNoneгЮ▀аЁprimal┌Because 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 ordering primal Source Ptrprimal!Offset in bytes into source arrayprimalDestinationprimal Offset in bytes into destinationprimalNumber of bytes to copy⌡primalSource arrayprimal!Offset in bytes into source arrayprimalDestination ptrprimal Offset in bytes into destinationprimalNumber of bytes to copy°primalSource arrayprimal!Offset in bytes into source arrayprimalDestinationprimal Offset in bytes into destinationprimalNumber of bytes to copy²primal Source ptrprimal!Offset in bytes into source arrayprimalDestination ptrprimal Offset in bytes into destinationprimalNumber of bytes to copyО÷═╗╧╨╩╪ҐЎ©юабцдефвьызшэщчъЮАБЦДУЖВЬЫЗШЭЩЧЪ─│┌┐ЦД╛╚ЫЗШЭЩЧЪ─ │ ┌ ┐ └ ┘ ├ ┤ ┬ ┴ ┼ ▀ ▄ █ ▌ ▐ ░ ▒ ▓ ⌠ ■ ∙ √ ≈ ≤ ≥ ⌡ ° ² · ÷ ═ ║ ╒ ё є ╔ і ї ╗ ╘ ╙ ╚ ╛ ґ ў ╞ ╟ ╠ ╡ Ё Є ╣ І Ї ╦ ╧ ╨ ╩ ╪ Ґ Ў © ю а б ц д е ф г х и й к л м н о п я р с т у ж в ь ы з ш э щ ч ъ Ю А Б Ц Д Е Ф Г Х И Й К Л М Н О П Я Р С Т У Ж В Ь Ы З Ш Э Щ Ч Ъ ─│┌┐└┘├┤┬┴┼▀▄█▌▐░▒▓⌠■∙√≈≤≥ ⌡°²·÷═║╒ёє╔ії╗╘╙╚╛ґў╞╟╠╡ЁЄ╣ІЇ╦╧╨╩╪ҐЎ©юабцдефгхийклмнопярстужвьызшэщчъЮАБЦДЕФГХИЙКЛМНОПЯРСТУЖВЬЫЗШЭЩЧЪ─│┌┐└┘├┤┬┴┼▀▄█▌▐░▒▓⌠■∙√≈≤≥ ⌡°²·÷═║╒ёє╔ії╗╘╙╚╛ґў╞╟╠╡ЁЄ╣6(c) Alexey Kuleshevich 2020BSD3(Alexey Kuleshevich experimentalnon-portableNoneг░uІprimalCast a Double into a 64bit WordЇprimalCast a 64bit Word into a Double╦primalCast a Float into a 32bit Word╧primalCast a 32bit Word into a Float╪primalArray to resizeprimalNew size of arrayprimalпNewly created slots initialized to this element. Only used when array is grown.ІЇ╦╧╨╩╪(c) Alexey Kuleshevich 2020BSD3(Alexey Kuleshevich experimentalnon-portableNoneг▒ Ь в n!"o#$p%&q'яр(ст)уж*вь+,-./02345678s9:;r<ыз=шэ>щч?ъЮ@ABцCдDEFG├┘└┐┌│─~}|{zyxwuvH▄▀┼┴┤┬I√∙■⌠▓▒░▐█▌JKLMNPQRSTUVWXYZ[\]^_`abcdefghijklm≈≤≥ ⌡°²·÷═║╒ёє╔ії╗╘╙╚╛ґў╞╟╠╡ЁЄ╣ІЇ╦╧╨╩╪ҐЎ©юабцдефгхийклмнопярстужвьызшэщчъЮАБЦДЕФГХИЙКЛМНОПЯРСТУЖВЬЫЗШЭЩЧЪ─│┌┐└┘├┤┬┴┼▀▄█▌▐░▒▓⌠■∙√≈≤≥ ⌡°²·÷═║╒ёє╔ії╗╘╙╚╛ґў╞╟╠╡ЁЄ╣ІЇ╦╧╨╩╪ҐЎ©юабцдефгхийклмнопярстужвьызшэщчъЮАБЦДЕФГХИЙКЛМНОПЯРСТУЖВЬЫЗШЭЩЧЪ─│┌┐└┘├┤┬┴┼▀▄█▌▐░▒▓⌠■∙√≈≤≥ ⌡°²·÷═║╒ёє╔ії╗╘╙╚╛ґў╞╟╠╡ЁЄ╣ІЇ╦╧╨╩╪ҐЎ©юабцдефгхийклмнопярстужвьызшэщчъЮАБЦДЕФГХИЙКЛМНОПЯРСТУЖВЬЫЗШЭЩЧЪ─│┌┐└┘├┤┬┴┼▀▄█▌▐░▒▓⌠■∙√≈≤≥ ⌡°²·÷═║╒ёє╔ії╗╘╙╚╛ґў╞╟╠╡ЁЄ╣ІЇ╦╧╨╩╪ҐЎ©юабцдефгхийклмнопярстужвьызшэщчъЮАБЦДЕФГХИЙКЛМНОПЯРСТУЖВЬЫЗШЭЩЧЪ─│┌┐└┘├┤┬┴┼▀▄█▌▐░▒▓⌠■∙√≈≤≥ ⌡°²·÷═║╒ёє╔ії╗╘╙╚╛ґў╞╟╠╡ЁЄ╣ІЇ╦╧╨╩╪ҐЎ©юабцдефгхийклмнопярстужвьызшэщчъЮАБЦДЕФГХИЙКЛМНОПЯРСТУЖВЬЫЗШЭЩЧЪ─│┌┐└┘├┤┬┴┼▀▄█▌▐░▒▓⌠■∙√≈≤≥ ⌡°²·÷═║╒ёє╔ії╗╘╙╚╛ґў╞╟╠╡ЁЄ╣ІЇ╦╧╨╩╪ҐЎ©юабцдефгхийклмнопярстужвьызшэщчъЮАБЦДЕФГХИЙКЛМНОПЯРСТУЖВЬЫЗШЭЩЧЪ─│┌┐└┘├┤┬┴┼▀▄█▌▐░▒▓⌠■∙√≈≤≥ ⌡°²·÷═║╒ёє╔ії╗╘╙╚╛ґў╞╟╠╡ЁЄ╣ІЇ╦╧╨╩╪ҐЎ©юабцдефгхийклмнопярстужвьызшэщчъЮАБЦДЕФГХИЙКЛМНОПЯРСТУЖВЬЫЗШЭЩЧЪ─│┌┐└┘├┤┬┴┼▀▄█▌▐░▒▓⌠■∙√≈≤≥ ⌡°²·÷═║╒ёє╔ії╗╘╙╚╛ґў╞╟╠╡ЁЄ╣ІЇ╦╧╨╩╪ҐЎ©юабцдефгхийклмнопярстужвьызшэщчъЮАБЦДЕФГХИЙКЛМНОПЯРСТУЖВЬЫЗШЭЩЧЪ─ │ ┌ ┐ └ ┘ ├ ┤ ┬ ┴ ┼ ▀ ▄ █ ▌ ▐ ░ ▒ ▓ ⌠ ■ ∙ √ ≈ ≤ ≥ ⌡ ° ² · ÷ ═ ║ ╒ ё є ╔ і ї ╗ ╘ ╙ ╚ ╛ ґ ў ╞ ╟ ╠ ╡ Ё Є ╣ І Ї ╦ ╧ ╨ ╩ ╪ Ґ Ў © ю а б ц д е ф г х и й к л м н о п я р с т у ж в ь ы з ш э щ ч ъ Ю А Б Ц Д Е Ф Г Х И Й К Л М Н О П Я Р С Т У Ж В Ь Ы З Ш Э Щ Ч Ъ ─ │ ┌ ┐ └ ┘ ├ ┤ ┬ ┴ ┼ ▀ ▄ █ ▌ ▐ ░ ▒ ▓ ⌠ ■ ∙ √ ≈ ≤ ≥ ⌡ ° ² · ÷ ═ ║ ╒ ё є ╔ і ї ╗ ╘ ╙ ╚ ╛ ґ ў ╞ ╟ ╠ ╡ Ё Є ╣ І Ї ╦ ╧ ╨ ╩ ╪ Ґ Ў © ю а б ц д е ф г х й йк л м н о п я р с ж у т в АБЦДЕФГХИЙКЛМНОПЯРСТУЖВЬЫЗШЭЩЧЪ─│┌┐└┘├┤┬┴┼▀▄█▌▐░▒▓⌠■∙√≈≤≥ ⌡°²╗їі·÷═║╒ёє╔ії╗╘╙╚╛ґў╞╟╠╡Ё╛╚Є╣ІЇ╦╧╨╩╪ҐЎ©юабцдефгхийклмнопяр╣ІстужвьызшэщчъЮАБЦДЕФГХИЙКЛМНОефПЯРСТУЖВЬЫЗШЭЩЧЪ─│┌┐└┘├┤┬┴опярстуА┼▀▄█▌▐░▒▓⌠■∙┐▌▐░⌠∙ЫЗШЭЩЧЪ─ │ ┌ ┐ └ ┘ ├ ┤ ┬ ┴ ┼ ▀ ▄ █ ▌ ▐ ░ ▒ ▓ ⌠ ■ ∙ √ ≈ ≤ ≥ ⌡ ° ² · ÷ ═ ║ ╒ ё є ╔ і ї ╗ ╘ ╙ ╚ ╛ ґ ў ╞ ╟ ╠ ╡ Ё Є ╣ І Ї ╦ ╧ ╨ ╩ ╪ Ґ Ў © ю а б ц д е ф г х и й к л м н о п я р с т у ж в ь ы з ш э щ ч ъ Ю А Б Ц Д Е Ф Г Х И Й К Л М Н О П Я Р С Т У Ж В Ь Ы З Ш Э Щ Ч Ъ ─│┌┐└┘├┤┬┴┼▀▄█▌▐░▒▓⌠■∙√≈≤≥ ⌡°²·÷═║╒ёє╔ії╗╘╙╚╛ґў╞╟╠╡ЁЄ╣ІЇ╦╧╨╩╪ҐЎ©юабцдефгхийклмнопярстужвьызшэщчъЮАБЦДЕФГХИЙКЛМНОПЯРСТУЖВЬЫЗШЭЩЧЪ─│┌┐└┘├┤┬┴┼▀▄█▌▐░▒▓⌠■∙√≈≤≥ ⌡°²·÷═║╒ёє╔ії╗╘╙╚╛ґў╞╟╠╡ЁЄ╣ІЇ╦╧╨╩╪ҐЎ©юаЦ ҐЎ©юа⌠∙╧вУ╨ьЖ╩ыВЎэЗ╪зЬҐшЫ©щШючЭаъЩбЮЧцАЪдБ─еЦ│фД┌ДЦ┐╛╚═÷╗ЫЗШЭЩЧЪ─ │ ┌ ┐ └ ┘ ├ ┤ ┬ ┴ ┼ ▀ ▄ █ ▌ ▐ ░ ▒ ▓ ⌠ ■ ∙ √ ≈ ≤ ≥ ⌡ ° ² · ÷ ═ ║ ╒ ё є ╔ і ї ╗ ╘ ╙ ╚ ╛ ґ ў ╞ ╟ ╠ ╡ Ё Є ╣ І Ї ╦ ╧ ╨ ╩ ╪ Ґ Ў © ю а б ц д е ф г х и й к л м н о п я р с т у ж в ь ы з ш э щ ч ъ Ю А Б Ц Д Е Ф Г Х И Й К Л М Н О П Я Р С Т У Ж В Ь Ы З Ш Э Щ Ч Ъ ─│┌┐└┘├┤┬┴┼▀▄█▌▐░▒▓⌠■∙√≈≤≥ ⌡°²·÷═║╒ёє╔ії╗╘╙╚╛ґў╞╟╠╡ЁЄ╣ІЇ╦╧╨╩╪ҐЎ©юабцдефгхийклмнопярстужвьызшэщчъЮАБЦДЕФГХИЙКЛМНОПЯРСТУЖВЬЫЗШЭЩЧЪ─│┌┐└┘├┤┬┴┼▀▄█▌▐░▒▓⌠■∙√≈≤≥Ё╡Є╣╠╟╞ў╚╙ґ╛їі╘╗ё╒╔є÷·║═²°⌡ ╧╦ЇІ╨╩╪┐8sу░й й▌▐ в n!"o#$p%&q'()*+,-./02345679:;r<=>?@ABцCдDEFG├┘└┐┌│─~}|{zyxwuvH▄▀┼┴┤┬I√∙■⌠▓▒░▐█▌JKLMNPQRSTUVWXYZ[\]^_`abcdefghijklm≈≤≥ ⌡°²·÷═║╒ёє╔ії╗╘╙╚╛ґў╞╟╠╡ЁЄ╣ІЇ╦╧╨╩╪ҐЎ©юабцдефгхийклмнопярстужвьызшэщчъЮАБЦДЕФГХИЙКЛМНОПЯРСТУЖВЬЫЗШЭЩЧЪ─│┌┐└┘├┤┬┴┼▀▄█▌▐░▒▓⌠■∙√≈≤≥ ⌡°²·÷═║╒ёє╔ії╗╘╙╚╛ґў╞╟╠╡ЁЄ╣ІЇ╦╧╨╩╪ҐЎ©юабцдефгхийклмнопярстужвьызшэщчъЮАБЦДЕФГХИЙКЛМНОПЯРСТУЖВЬЫЗШЭЩЧЪ─│┌┐└┘├┤┬┴┼▀▄█▌▐░▒▓⌠■∙√≈≤≥ ⌡°²·÷═║╒ёє╔ії╗╘╙╚╛ґў╞╟╠╡ЁЄ╣ІЇ╦╧╨╩╪ҐЎ©юабцдефгхийклмнопярстужвьызшэщчъЮАБЦДЕФГХИЙКЛМНОПЯРСТУЖВЬЫЗШЭЩЧЪ─│┌┐└┘├┤┬┴┼▀▄█▌▐░▒▓⌠■∙√≈≤≥ ⌡°²·÷═║╒ёє╔ії╗╘╙╚╛ґў╞╟╠╡ЁЄ╣ІЇ╦╧╨╩╪ҐЎ©юабцдефгхийклмнопярстужвьызшэщчъЮАБЦДЕФГХИЙКЛМНОПЯРСТУЖВЬЫЗШЭЩЧЪ─│┌┐└┘├┤┬┴┼▀▄█▌▐░▒▓⌠■∙√≈≤≥ ⌡°²·÷═║╒ёє╔ії╗╘╙╚╛ґў╞╟╠╡ЁЄ╣ІЇ╦╧╨╩╪ҐЎ©юабцдефгхийклмнопярстужвьызшэщчъЮАБЦДЕФГХИЙКЛМНОПЯРСТУЖВЬЫЗШЭЩЧЪ─│┌┐└┘├┤┬┴┼▀▄█▌▐░▒▓⌠■∙√≈≤≥ ⌡°²·÷═║╒ёє╔ії╗╘╙╚╛ґў╞╟╠╡ЁЄ╣ІЇ╦╧╨╩╪ҐЎ©юабцдефгхийклмнопярстужвьызшэщчъЮАБЦДЕФГХИЙКЛМНОПЯРСТУЖВЬЫЗШЭЩЧЪ─│┌┐└┘├┤┬┴┼▀▄█▌▐░▒▓⌠■∙√≈≤≥ ⌡°²·÷═║╒ёє╔ії╗╘╙╚╛ґў╞╟╠╡ЁЄ╣ІЇ╦╧╨╩╪ҐЎ©юабцдефгхийклмнопярстужвьызшэщчъЮАБЦДЕФГХИЙКЛМНОПЯРСТУЖВЬЫЗШЭЩЧЪ─│┌┐└┘├┤┬┴┼▀▄█▌▐░▒▓⌠■∙√≈≤≥ ⌡°²·÷═║╒ёє╔ії╗╘╙╚╛ґў╞╟╠╡ЁЄ╣ІЇ╦╧╨╩╪ҐЎ©юабцдефгхийклмнопярстужвьызшэщчъЮАБЦДЕФГХИЙКЛМНОПЯРСТУЖВЬЫЗШЭЩЧЪ─ │ ┌ ┐ └ ┘ ├ ┤ ┬ ┴ ┼ ▀ ▄ █ ▌ ▐ ░ ▒ ▓ ⌠ ■ ∙ √ ≈ ≤ ≥ ⌡ ° ² · ÷ ═ ║ ╒ ё є ╔ і ї ╗ ╘ ╙ ╚ ╛ ґ ў ╞ ╟ ╠ ╡ Ё Є ╣ І Ї ╦ ╧ ╨ ╩ ╪ Ґ Ў © ю а б ц д е ф г х и й к л м н о п я р с т у ж в ь ы з ш э щ ч ъ Ю А Б Ц Д Е Ф Г Х И Й К Л М Н О П Я Р С Т У Ж В Ь Ы З Ш Э Щ Ч Ъ ─ │ ┌ ┐ └ ┘ ├ ┤ ┬ ┴ ┼ ▀ ▄ █ ▌ ▐ ░ ▒ ▓ ⌠ ■ ∙ √ ≈ ≤ ≥ ⌡ ° ² · ÷ ═ ║ ╒ ё є ╔ і ї ╗ ╘ ╙ ╚ ╛ ґ ў ╞ ╟ ╠ ╡ Ё Є ╣ І Ї ╦ ╧ ╨ ╩ ╪ Ґ Ў © ю а б ц д е ф г х к л м н о п я р с ж у т в ╗їі╣ІефопярстА (c) Alexey Kuleshevich 2020BSD3(Alexey Kuleshevich experimentalnon-portableNone./9>?югинжвыЮ╡qбprimalInvariants:experimentalnon-portableNone29>?югинвыл БprimalRead an element from -) atomically. Implies full memory barrier.ЦprimalWrite an element into -) atomically. Implies full memory barrier.ДprimalдRead an element from memory atomically. Implies full memory barrier.ЕprimalнWrite an element directly into memory atomically. Implies full memory barrier.ФprimalЪCompare-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 -ю. 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 -ю. This is essentially an implementation of a spinlock using CAS.МprimalUsing Х1 perform atomic modification of an element in a -. Returns the previous value.НprimalUsing Ф1 perform atomic modification of an element in a -. Returns the previous value.ОprimalUsing Ф1 perform atomic modification of an element in a -. Returns the new value.ПprimalUsing Ф1 perform atomic modification of an element in a -.Я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#.Уprimal┘Flip all bits atomically in the element of an array at the supplied offset. Returns the previous value. Implies full memory barrier.Жprimal─Flip all bits atomically in the element of an array at the supplied offset. Returns the new value. Implies full memory barrier.Вprimal┘Flip all bits atomically in the element of an array at the supplied offset. Returns the previous value. Implies full memory barrier.Ьprimal─Flip 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 architectures╘primal%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 architecturesрprimal%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 architecturesВprimal%Available only on 64bit architecturesБprimal&Mutable array to read the element fromprimal+Offset into the array in number of elementsЦprimal'Mutable array to write the element intoprimal+Offset into the array in number of elementsprimalElement to writeДprimal"Pointer to the beginning of memoryprimal6Offset in number of elements from the supplied pointerЕprimal"Pointer to the beginning of memoryprimal6Offset in number of elements from the supplied pointerprimalElement to writeФprimalArray to be mutatedprimal+Offset into the array in number of elementsprimalExpected old valueprimal New valueprimalStarting stateХprimalArray to be mutatedprimal+Offset into the array in number of elementsprimalExpected old valueprimal New valueprimalStarting stateЙprimalArray to be mutatedprimalIndex in number of % elements into the -primal0Function to be applied atomically to the elementprimalStarting stateКprimalArray to be mutatedprimalIndex in number of % elements into the OffAddr#primal0Function to be applied atomically to the elementprimalStarting stateЛprimalArray to be mutatedprimalIndex in number of % elements into the -primal0Function to be applied atomically to the elementprimalStarting stateМprimalArray to be mutatedprimalIndex in number of % elements into the -primal0Function to be applied atomically to the elementprimalStarting stateНprimalArray to be mutatedprimalIndex in number of % elements into the -primal0Function to be applied atomically to the elementprimalStarting stateОprimalArray to be mutatedprimalIndex in number of % elements into the -primal0Function to be applied atomically to the elementprimalStarting stateПprimalArray to be mutatedprimalIndex in number of % elements into the -primal0Function to be applied atomically to the elementprimalStarting stateЯprimalArray to be mutatedprimalIndex in number of % elements into the OffAddr#primal0Function to be applied atomically to the elementprimalStarting stateРprimalArray to be mutatedprimalIndex in number of % elements into the OffAddr#primal0Function to be applied atomically to the elementprimalStarting stateСprimalArray to be mutatedprimalIndex in number of % elements into the OffAddr#primal0Function to be applied atomically to the elementprimalStarting stateТprimalArray 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 experimentalnon-portableNone?гтытч┐primalWrapper for Ън. Sleep specified number of microseconds. Not designed for threaded runtime: Errors when compiled with -threaded└primalWrapper for ─7. Block and wait for input to become available on the ▐%. Not designed for threaded runtime: Errors out when compiled with -threaded┘primalWrapper for │1. Block and wait until output is possible on the ▐&. Not designed for threaded runtime: Errors out when compiled with -threaded├primalWrapper around ┌ . Unlike 78Д it does not install any exception handlers on the action, so you need make sure to do it yourself.┤primal╛Spawn a thread and run an action in it. Any exception raised by the new thread will be passed to the supplied exception handler, which itself will be run in a masked state┬primalWrapper around ┐ . Unlike 79Д 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.▄primalLifted version of √█primalLifted version of ≈▌primalSame as █, but ignores the outcome▐primal Just like 7: this is a Wrapper around ┘ь primop , except that this version works for any state token. It is safe to use within й ╚ because it can't affect the result of computation, just the order of evaluation with respect to other threads, which is not relevant for the state thread monad anyways.░primalWrapper around ├.▒primal4Pointer should refer to UTF8 encoded string of bytes▓primal)Check if current thread was spawned with ┐≈primal$Something that is not exported from base: convert a Б to a regular integral type.И╒ёє╔ії╗╘╙╚╛ґў/й ╞╟║╠╡ЁЄ╣ІЇ╦╧╨╩╪Б А ҐЎ©юиаубцдефг═хийкБЫЗШЧЭЩЪ─│┌┐└┘├┤┬┴┼▀▄█▌▐░≈≤≥ °²─│┌┐└┘├┤┬┴┼▀▄█▌▐░▒▓⌠■∙√≈Б А ├┤┬┴┼▀▐▄█▌░≈⌠▒▓■∙√─│┌┐└┘(c) Alexey Kuleshevich 2020BSD3(Alexey Kuleshevich experimentalnon-portableNone/>?югинжвыж{!≤≥ ⌡°²·÷═║╒ёє╔ії╗╘╙╚╛ґў╞╟╠╡ЁЄ╣ІЇ╦!≤≥ ⌡°²·÷═║╒ёє╔ії╗╘╙╚╛ґў╞╟╠╡ЁЄ╣ІЇ╦(c) Alexey Kuleshevich 2020BSD3(Alexey Kuleshevich experimentalnon-portableNone гинвыБйprimalOffset in number of elementsмprimalNumber of elementsпprimal2Helper function that converts a type into a stringяprimalбGet 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 я, but argument is a ╙ of e, instead of the type itself.import Data.Primimport Data.Proxy%byteCountProxy (Proxy :: Proxy Int64)Count {unCount = 8}тprimalбGet 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 @Int324жprimalSame as т, but argument is a ╙ of a, instead of the type itself.import Data.Proxy%alignmentProxy (Proxy :: Proxy Int64)8ьprimalбCovert an element count to number of bytes it coresponds to as an &. See ы for preserving the м wrapper.ыprimalCovert to the м of bytesзprimal*Cast a count to an offset of the same typeэprimal$Helper noop function that restricts м to the type of proxyщprimalRestrict type argument of мх to the same type as the second argument, which itself is not evaluatedчprimal"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 proxyАprimalRestrict type argument of йх to the same type as the second argument, which itself is not evaluatedБprimal9Cast an offset to count. Useful for dealing with regions.import Data.Prim'let totalCount = Count 10 :: Count Word#let startOffset = 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 &.unOffBytes (10 :: Off Word64)80Фprimal0Convert offset of some type into number of bytesМprimalпCoerce result of a function (it is also a hidden function in Data.Functor.Utils)Нprimal0Coerce result of a function. Flipped version of М├≤≥ ⌡&ясув/;ышщъBJи й °²·÷═║╒ёє╔ії╗╘╙╚╛ґў╞╟╠╡ЁЄ╣░▐▌ІЇ⌠▓▒√∙■≥≤≈°⌡ ÷·²╒║═╔єё╙╘КЛМНОЖЩи╦Ъ┐бгьА≤≥ йклмнопярстужвьызшэщчъЮАБЦДЕФГХИЙКЛМНрб≤≥ АьгЪ┐/й ипярстужмноьывчъзшщэйклЕДФГХБЦАЮИЙКЛBи ╙╘МН░▐▌⌠▓▒√∙■≥≤≈°⌡ ÷·²╒║═╔єё(c) Alexey Kuleshevich 2020BSD3(Alexey Kuleshevich experimentalnon-portableNone?гийнтвыЮ╣0К┤primalSmall boxed mutable array┴primalSmall boxed immutable array▀primal"Mutable array with boxed elements.█primal$Immutable array with boxed elements.▓primalжCompare pointers for two immutable arrays and see if they refer to the exact same one.⌠primalO(1)3 - Get the number of elements in an immutable array#Documentation for utilized primop: Ч.■primalO(1)1 - Index an element in the immutable boxed array.#Documentation for utilized primop: ─. Unsafe0Bounds are not checked. When a precondition for ixэ argument is violated the result is either unpredictable output or failure with a segfault.Examplesimport Data.Prim.Array9let a = fromListBArray [[0 .. i] | i <- [0 .. 10 :: Int]]indexBArray a 1[0,1]indexBArray a 5 [0,1,2,3,4,5]∙primalO(sz)ю - Make an exact copy of a subsection of a pure immutable array. Unsafe"When any of the preconditions for startIx or szу is violated this function can result in a copy of some data that doesn't belong to srcArrayЖ or more likely a failure with a segfault. Failure with out of memory is also possibility when the @sz is too large.#Documentation for utilized primop: ┘.Examples!let a = fromListBArray ['a'..'z']a#BArray "abcdefghijklmnopqrstuvwxyz"cloneBArray a 23 3BArray "xyz"√primalO(sz)÷ - Copy a subsection of an immutable array into a subsection of a mutable array. Source and destination arrays must not be the same array in different states.#Documentation for utilized primop: ┐. Unsafe"When any of the preconditions for srcStartIx, dstStartIx or szу is violated this function can result in a copy of some data that doesn't belong to srcArray+ or more likely a failure with a segfault.≈primalO(1)и - Convert a pure immutable boxed array into a mutable boxed array. Use ╗* in order to go in the opposite direction.#Documentation for utilized primop: ┌. UnsafeоThis function makes it possible to break referential transparency, because any subsequent destructive operation to the mutable boxed array will also be reflected in the source immutable array as well. See ≤а that avoids this problem with a fresh allocation and data copy.Examples5ma <- thawBArray $ fromListBArray [1 .. 5 :: Integer]writeBMArray ma 1 10freezeBMArray maBArray [1,10,3,4,5]ОBe careful not to retain a reference to the pure immutable source array after the thawed version gets mutated.*let a = fromListBArray [1 .. 5 :: Integer]ma' <- thawBArray awriteBMArray ma' 0 100000aBArray [100000,2,3,4,5]≤primalO(sz)( - Create a new mutable array with size sz9 and copy that number of elements from source immutable srcArray starting at an offset startIx into the newly created dstMutArrayш. This function can help avoid an issue with referential transparency that is inherent to ≈. Unsafe"When any of the preconditions for startIx or szу is violated this function can result in a copy of some data that doesn't belong to srcArrayЬ or more likely a failure with a segfault. Failure with out of memory is also a possibility when the @sz is too large.#Documentation for utilized primop: ┬.Examples&let a = fromListBArray [1 .. 5 :: Int]ma <- thawCopyBArray a 1 3writeBMArray ma 1 10freezeBMArray maBArray [2,10,4]aBArray [1,2,3,4,5]≥primalшConvert a pure boxed array into a list. It should work fine with GHC built-in list fusion. primalO(min(length list, sz)) - Same as ⌡4, except that it will allocate an array exactly of nЙ size, as such it will not convert any portion of the list that doesn't fit into the newly created array. PartialгWhen length of supplied list is in fact smaller then the expected size sz, thunks with Ж н exception throwing function will be placed in the tail portion of the array.UnsafeWhen a precondition szя is violated this function can result in critical failure with out of memory or С async exception.Examples"fromListBArrayN 3 [1 :: Int, 2, 3]BArray [1,2,3]fromListBArrayN 3 [1 :: Int ..]BArray [1,2,3]⌡primalO(length list)н - Convert a list into an immutable boxed array. It is more efficient to use с when the number of elements is known ahead of time. The reason for this is that it is necessary to iterate the whole list twice: once to count how many elements there is in order to create large enough array that can fit them; and the second time to load the actual elements. Naturally, infinite lists will grind the program to a halt.ExamplefromListBArray "Hello Haskell"BArray "Hello Haskell"°primalO(1) - cast a boxed immutable ╧ that is wired with GHC to █ from primal.import Data.Array.IArray as IAбlet arr = IA.listArray (10, 15) [30 .. 35] :: IA.Array Int Integerarr?array (10,15) [(10,30),(11,31),(12,32),(13,33),(14,34),(15,35)]fromBaseBArray arrBArray [30,31,32,33,34,35]²primalO(1) - cast a boxed █ from primal into ╧ы, which is wired with GHC. Resulting array range starts at 0, like any sane array would.-let arr = fromListBArray [1, 2, 3 :: Integer]arrBArray [1,2,3]toBaseBArray arrarray (0,2) [(0,1),(1,2),(2,3)]·primalтCompare pointers for two mutable arrays and see if they refer to the exact same one.#Documentation for utilized primop: Ш.÷primalO(1)( - Get the size of a mutable boxed array#Documentation for utilized primop: Ъ.Example,ma <- newBMArray 1024 "Element of each cell"getSizeOfBMArray maSize {unSize = 1024}═primalO(1)д - Read an element from a mutable boxed array at the supplied index.#Documentation for utilized primop: Э. Unsafe Violation of ixм preconditions can result in undefined behavior or a failure with a segfaultExample8ma <- makeBMArray 10 (pure . ("Element ix: " ++) . show)readBMArray ma 5"Element ix: 5"║primalO(1) - Write an element elt into the mutable boxed array dstMutArray at the supplied index ixа. The actual element will be evaluated to WHNF prior to mutation. Unsafe Violation of ixй preconditions can result in heap corruption or a failure with a segfaultExamples-ma <- newBMArray 4 (Nothing :: Maybe Integer)writeBMArray ma 2 (Just 2)freezeBMArray ma'BArray [Nothing,Nothing,Just 2,Nothing]╠It is important to note that an element is evaluated prior to being written into a cell, so it will not overwrite the value of an array's cell if it evaluates to an exception:import Control.Prim.Exception,writeBMArray ma 2 (impureThrow DivideByZero)*** Exception: divide by zerofreezeBMArray ma'BArray [Nothing,Nothing,Just 2,Nothing]▐However, it is evaluated only to Weak Head Normal Form (WHNF), so it is still possible to write something that eventually evaluates to bottom.%writeBMArray ma 3 (Just (7 `div` 0 ))freezeBMArray maаBArray [Nothing,Nothing,Just 2,Just *** Exception: divide by zeroreadBMArray ma 3"Just *** Exception: divide by zeroEither ■ or ё can be used to alleviate that.╒primalO(1) - Same as ║▌ but allows to write a thunk into an array instead of an evaluated element. Careful with memory leaks and thunks that evaluate to exceptions.#Documentation for utilized primop: Щ. UnsafeSame reasons as ║ёprimalO(1) - Same as ║ъ, except it ensures that the value being written is fully evaluated, i.e. to Normal Form (NF). UnsafeSame reasons as ║єprimalжCreate a mutable boxed array where each element is set to the supplied initial value elt:, which is evaluated before array allocation happens. See ╔, for an ability to initialize with a thunk. Unsafe size"Violation of precondition for the sz> argument can result in the current thread being killed with С ч asynchronous exception or death of the whole process with some unchecked exception from RTS.Examples#newBMArray 10 'A' >>= freezeBMArrayBArray "AAAAAAAAAA"╔primalSame as є2, except initial element is allowed to be a thunk.#Documentation for utilized primop: З. UnsafeSame reasons as єіprimalЩCreate new mutable array, where each element is initilized to a thunk that throws an error when evaluated. This is useful when there is a plan to later iterate over the whole array and write values into each cell in some index aware fashion. Consider ї as an alternative. Partial7All array cells are initialized with thunks that throw Ж exception when evaluatedUnsafeSame reasons as єExamplesimport Data.Primlet xs = "Hello Haskell">ma <- newRawBMArray (Size (length xs)) :: IO (BMArray Char RW)5mapM_ (\(i, x) -> writeBMArray ma i x) (zip [0..] xs)freezeBMArray maBArray "Hello Haskell"їprimal┘Create new mutable boxed array of the supplied size and fill it with a monadic action that is applied to indices of each array cell. UnsafeSame reasons as єExamplesЮma <- makeBMArray 5 $ \i -> (toEnum (i + 97) :: Char) <$ putStrLn ("Handling index: " ++ show i)Handling index: 0Handling index: 1Handling index: 2Handling index: 3Handling index: 4freezeBMArray maBArray "abcde"╗primalO(1)< - Convert a mutable boxed array into an immutable one. Use ≈+ in order to go in the opposite direction.#Documentation for utilized primop: │. UnsafeяThis function makes it possible to break referential transparency, because any subsequent destructive operation to the source mutable boxed array will also be reflected in the resulting immutable array. See ╘1 that avoids this problem with fresh allocation.╘primalO(sz) - Similar to ╗Ы, except it creates a new array with the copy of a subsection of a mutable array before converting it into an immutable.#Documentation for utilized primop: ┤. Unsafe"When any of the preconditions for startIx or szу is violated this function can result in a copy of some data that doesn't belong to srcArrayф or more likely a failure with a segfault or out of memory exception.╙primalO(sz)( - Allocate a new mutable array of size sz5 and copy that number of the elements over from the srcArray starting at index ix . Similar to ∙%, except it works on mutable arrays.#Documentation for utilized primop: ├. Unsafe"When any of the preconditions for startIx or szу is violated this function can result in a copy of some data that doesn't belong to srcArrayЬ or more likely a failure with a segfault. Failure with out of memory is also a possibility when the @sz is too large.╚primalO(1), - Reduce the size of a mutable boxed array.#Documentation for utilized primop: ╩. Unsafe!- Violation of preconditions for sz leads to undefined behavior 3.0╛primalO(1)У - Either grow or shrink the size of a mutable unboxed array. Shrinking happens in-place without new array creation and data copy, while growing the array is implemented with creating new array and copy of the data over from the source array srcMutArray-. This has a consequence that produced array dstMutArray might refer to the same srcMutArray7 or to a totally new array, which can be checked with ·.&Documentation on the utilized primop: ╪. Unsafe- Same reasons as in і. 3.0ґprimalO(1) - Same as ╛н, except when growing the array empty space at the end is filled with bottom. Partial- When size sz is larger then the size of srcMutArray then dstMutArrayю will have cells at the end initialized with thunks that throw Ж exception.Unsafe- Same reasons as in є. 3.0ўprimalO(sz)С - Copy a subsection of a mutable array into a subsection of another or the same mutable array. Therefore, unlike √?, memory ia allowed to overlap between source and destination.#Documentation for utilized primop: └. Unsafe"When any of the preconditions for srcStartIx, dstStartIx or szу is violated this function can result in a copy of some data that doesn't belong to srcArray+ or more likely a failure with a segfault.╞primalжCompare pointers for two immutable arrays and see if they refer to the exact same one.╟primalO(1)3 - Get the number of elements in an immutable array#Documentation for utilized primop: ▐.╠primalO(1)7 - Index an element in the immutable small boxed array.#Documentation for utilized primop: ▓. Unsafe0Bounds are not checked. When a precondition for ixэ argument is violated the result is either unpredictable output or failure with a segfault.Examplesimport Data.Prim.Array:let a = fromListSBArray [[0 .. i] | i <- [0 .. 10 :: Int]]indexSBArray a 1[0,1]indexSBArray a 5 [0,1,2,3,4,5]╡primalO(sz)ю - Make an exact copy of a subsection of a pure immutable array. Unsafe"When any of the preconditions for startIx or szу is violated this function can result in a copy of some data that doesn't belong to srcArrayЬ or more likely a failure with a segfault. Failure with out of memory is also a possibility when the @sz is too large.#Documentation for utilized primop: ≈.Examples"let a = fromListSBArray ['a'..'z']a$SBArray "abcdefghijklmnopqrstuvwxyz"cloneSBArray a 23 3 SBArray "xyz"ЁprimalO(1)2 - Reduce the size of a mutable small boxed array.#Documentation for utilized primop: ▄. Unsafe!- Violation of preconditions for sz leads to undefined behavior 3.0ЄprimalO(1)У - Either grow or shrink the size of a mutable unboxed array. Shrinking happens in-place without new array creation and data copy, while growing the array is implemented with creating new array and copy of the data over from the source array srcMutArray-. This has a consequence that produced array dstMutArray might refer to the same srcMutArray7 or to a totally new array, which can be checked with ╪.&Documentation on the utilized primop: н . Unsafe- Same reasons as in д. 3.0╣primalO(1) - Same as Єн, except when growing the array empty space at the end is filled with bottom. Partial- When size sz is larger then the size of srcMutArray then dstMutArrayю will have cells at the end initialized with thunks that throw Ж exception.Unsafe- Same reasons as in б. 3.0ІprimalO(sz)÷ - Copy a subsection of an immutable array into a subsection of a mutable array. Source and destination arrays must not be the same array in different states.#Documentation for utilized primop: ∙. Unsafe"When any of the preconditions for srcStartIx, dstStartIx or szу is violated this function can result in a copy of some data that doesn't belong to srcArray+ or more likely a failure with a segfault.ЇprimalO(1)и - Convert a pure immutable boxed array into a mutable boxed array. Use ф* in order to go in the opposite direction.#Documentation for utilized primop: ■. UnsafeоThis function makes it possible to break referential transparency, because any subsequent destructive operation to the mutable boxed array will also be reflected in the source immutable array as well. See ╦а that avoids this problem with a fresh allocation and data copy.Examples7ma <- thawSBArray $ fromListSBArray [1 .. 5 :: Integer]writeSBMArray ma 1 10freezeSBMArray maSBArray [1,10,3,4,5]ОBe careful not to retain a reference to the pure immutable source array after the thawed version gets mutated.+let a = fromListSBArray [1 .. 5 :: Integer]ma' <- thawSBArray awriteSBMArray ma' 0 100000aSBArray [100000,2,3,4,5]╦primalO(sz)( - Create a new mutable array with size sz9 and copy that number of elements from source immutable srcArray starting at an offset startIx into the newly created dstMutArrayш. This function can help avoid an issue with referential transparency that is inherent to Ї. Unsafe"When any of the preconditions for startIx or szу is violated this function can result in a copy of some data that doesn't belong to srcArrayЬ or more likely a failure with a segfault. Failure with out of memory is also a possibility when the @sz is too large.#Documentation for utilized primop: .Examples'let a = fromListSBArray [1 .. 5 :: Int]ma <- thawCopySBArray a 1 3writeSBMArray ma 1 10freezeSBMArray maSBArray [2,10,4]aSBArray [1,2,3,4,5]╧primalшConvert a pure boxed array into a list. It should work fine with GHC built-in list fusion.╨primalO(min(length list, sz)) - Same as ╩4, except that it will allocate an array exactly of nЙ size, as such it will not convert any portion of the list that doesn't fit into the newly created array. PartialгWhen length of supplied list is in fact smaller then the expected size sz, thunks with Ж н exception throwing function will be placed in the tail portion of the array.UnsafeWhen a precondition szя is violated this function can result in critical failure with out of memory or С async exception.Examples#fromListSBArrayN 3 [1 :: Int, 2, 3]SBArray [1,2,3] fromListSBArrayN 3 [1 :: Int ..]SBArray [1,2,3]╩primalO(length list)н - Convert a list into an immutable boxed array. It is more efficient to use ╨с when the number of elements is known ahead of time. The reason for this is that it is necessary to iterate the whole list twice: once to count how many elements there is in order to create large enough array that can fit them; and the second time to load the actual elements. Naturally, infinite lists will grind the program to a halt.ExamplefromListSBArray "Hello Haskell"SBArray "Hello Haskell"╪primalтCompare pointers for two mutable arrays and see if they refer to the exact same one.#Documentation for utilized primop: ▀.ҐprimalO(1)( - Get the size of a mutable boxed array#Documentation for utilized primop: ▒) for ghc-8.10 and newer and fallback to Ъ for older versions.Example-ma <- newSBMArray 1024 "Element of each cell"getSizeOfSBMArray maSize {unSize = 1024}ЎprimalO(1)й - Read an element from a mutable small boxed array at the supplied index.#Documentation for utilized primop: █. Unsafe Violation of ixм preconditions can result in undefined behavior or a failure with a segfaultExample9ma <- makeSBMArray 10 (pure . ("Element ix: " ++) . show)readSBMArray ma 5"Element ix: 5"©primalO(1) - Write an element elt$ into the mutable small boxed array dstMutArray at the supplied index ixб. The actual element will be evaluated to WHNF prior to mutation. Unsafe Violation of ixй preconditions can result in heap corruption or a failure with a segfaultExamples.ma <- newSBMArray 4 (Nothing :: Maybe Integer)writeSBMArray ma 2 (Just 2)freezeSBMArray ma(SBArray [Nothing,Nothing,Just 2,Nothing]╠It is important to note that an element is evaluated prior to being written into a cell, so it will not overwrite the value of an array's cell if it evaluates to an exception:import Control.Prim.Exception-writeSBMArray ma 2 (impureThrow DivideByZero)*** Exception: divide by zerofreezeSBMArray ma(SBArray [Nothing,Nothing,Just 2,Nothing]▐However, it is evaluated only to Weak Head Normal Form (WHNF), so it is still possible to write something that eventually evaluates to bottom.&writeSBMArray ma 3 (Just (7 `div` 0 ))freezeSBMArray maбSBArray [Nothing,Nothing,Just 2,Just *** Exception: divide by zeroEither ■ or а can be used to alleviate that.юprimalO(1) - Same as ©▌ but allows to write a thunk into an array instead of an evaluated element. Careful with memory leaks and thunks that evaluate to exceptions.#Documentation for utilized primop: ▌. UnsafeSame reasons as ©аprimalO(1) - Same as ©ъ, except it ensures that the value being written is fully evaluated, i.e. to Normal Form (NF). UnsafeSame reasons as ©бprimalжCreate a mutable boxed array where each element is set to the supplied initial value elt:, which is evaluated before array allocation happens. See ц, for an ability to initialize with a thunk. Unsafe size"Violation of precondition for the sz> argument can result in the current thread being killed with С ч asynchronous exception or death of the whole process with some unchecked exception from RTS.Examples%newSBMArray 10 'A' >>= freezeSBMArraySBArray "AAAAAAAAAA"цprimalSame as б2, except initial element is allowed to be a thunk.#Documentation for utilized primop: ┼. UnsafeSame reasons as бдprimalЩCreate new mutable array, where each element is initilized to a thunk that throws an error when evaluated. This is useful when there is a plan to later iterate over the whole array and write values into each cell in some index aware fashion. Consider е as an alternative. Partial7All array cells are initialized with thunks that throw Ж exception.UnsafeSame reasons as бExamplesimport Data.Primlet xs = "Hello Haskell"юma <- newRawSBMArray (Size (length xs)) :: IO (SBMArray Char RW)6mapM_ (\(i, x) -> writeSBMArray ma i x) (zip [0..] xs)freezeSBMArray maSBArray "Hello Haskell"еprimal┘Create new mutable boxed array of the supplied size and fill it with a monadic action that is applied to indices of each array cell. UnsafeSame reasons as бExamplesАma <- makeSBMArray 5 $ \i -> (toEnum (i + 97) :: Char) <$ putStrLn ("Handling index: " ++ show i)Handling index: 0Handling index: 1Handling index: 2Handling index: 3Handling index: 4freezeSBMArray maSBArray "abcde"фprimalO(1)< - Convert a mutable boxed array into an immutable one. Use Ї+ in order to go in the opposite direction.#Documentation for utilized primop: ⌠. UnsafeяThis function makes it possible to break referential transparency, because any subsequent destructive operation to the source mutable boxed array will also be reflected in the resulting immutable array. See г1 that avoids this problem with fresh allocation.гprimalO(sz) - Similar to фЫ, except it creates a new array with the copy of a subsection of a mutable array before converting it into an immutable.#Documentation for utilized primop: ≥. Unsafe"When any of the preconditions for startIx or szу is violated this function can result in a copy of some data that doesn't belong to srcArrayф or more likely a failure with a segfault or out of memory exception.хprimalO(sz)4 - Allocate a new small boxed mutable array of size sz5 and copy that number of the elements over from the srcArray starting at index ix. Similar to ╡), except that it works on mutable arrays.#Documentation for utilized primop: ≤. Unsafe"When any of the preconditions for startIx or szу is violated this function can result in a copy of some data that doesn't belong to srcArrayЬ or more likely a failure with a segfault. Failure with out of memory is also a possibility when the @sz is too large.иprimalO(sz)С - Copy a subsection of a mutable array into a subsection of another or the same mutable array. Therefore, unlike І?, memory ia allowed to overlap between source and destination.#Documentation for utilized primop: √. Unsafe"When any of the preconditions for srcStartIx, dstStartIx or szу is violated this function can result in a copy of some data that doesn't belong to srcArray+ or more likely a failure with a segfault.йprimalO(1)ы - Compare pointers for two immutable arrays and see if they refer to the exact same one.#Documentation for utilized primop: Ё.кprimalO(1)г - Check if memory for immutable unboxed array was allocated as pinned.#Documentation for utilized primop: ═.лprimalO(1)< - Get the size of an immutable array in number of elements.#Documentation for utilized primop: і.мprimalO(1), - Index an element of a pure unboxed array.#Documentation for utilized primop: к. Unsafe0Bounds are not checked. When a precondition for ixэ argument is violated the result is either unpredictable output or failure with a segfault.Examplesдlet a = fromListUArray ([Left pi, Right 123] :: [Either Double Int])indexUArray a 0Left 3.141592653589793indexUArray a 1 Right 123нprimalO(sz)╔ - Copy a subsection of an immutable array into a subsection of another mutable array. Source and destination arrays must not be the same array in different states.#Documentation for utilized primop: └. Unsafe"When any of the preconditions for srcStartIx, dstStartIx or szу is violated this function can result in a copy of some data that doesn't belong to srcArray or failure with a segfault.оprimalO(1)м - Convert a pure immutable unboxed array into a mutable unboxed array. Use Г* in order to go in the opposite direction.#Documentation for utilized primop: Ґ. UnsafeлThis function makes it possible to break referential transparency, because any subsequent destructive operation to the mutable unboxed array will also be reflected in the source immutable array as well.Examples1ma <- thawUArray $ fromListUArray [1 .. 5 :: Int]writeUMArray ma 1 10freezeUMArray maUArray [1,10,3,4,5]ОBe careful not to retain a reference to the pure immutable source array after the thawed version gets mutated.&let a = fromListUArray [1 .. 5 :: Int]ma' <- thawUArray awriteUMArray ma' 0 100000aUArray [100000,2,3,4,5]пprimalO(n)ч - Convert a pure boxed array into a list. It should work fine with GHC built-in list fusion.яprimalO(min(length list, sz)) - Same as р., except it will allocate an array exactly of nК size, as such it will not convert any portion of the list that doesn't fit into the newly created array. PartialгWhen length of supplied list is in fact smaller then the expected size sz, thunks with Ж н exception throwing function will be placed in the tail portion of the array.UnsafeWhen a precondition szя is violated this function can result in critical failure with out of memory or С async exception.Examples"fromListUArrayN 3 [1 :: Int, 2, 3]UArray [1,2,3]fromListUArrayN 3 [1 :: Int ..]UArray [1,2,3]рprimalO(length list)н - Convert a list into an immutable boxed array. It is more efficient to use яс when the number of elements is known ahead of time. The reason for this is that it is necessary to iterate the whole list twice: once to count how many elements there is in order to create large enough array that can fit them; and the second time to load the actual elements. Naturally, infinite lists will grind the program to a halt.ExamplefromListUArray "Hello Haskell"UArray "Hello Haskell"сprimalO(1) - cast an unboxed ╨ that is wired with GHC to ┘ from primal.import Data.Array.IArray as IAimport Data.Array.Unboxed as UAаlet uarr = IA.listArray (10, 15) [30 .. 35] :: UA.UArray Int Worduarr?array (10,15) [(10,30),(11,31),(12,32),(13,33),(14,34),(15,35)]fromBaseUArray uarrUArray [30,31,32,33,34,35]тprimalO(1) - cast an unboxed ┘ from primal into ╨ы, which is wired with GHC. Resulting array range starts at 0, like any sane array would.*let uarr = fromListUArray [1, 2, 3 :: Int]uarrUArray [1,2,3]toBaseUArray uarrarray (0,2) [(0,1),(1,2),(2,3)]уprimalO(1)в - Compare pointers for two mutable arrays and see if they refer to the exact same one.#Documentation for utilized primop: ╒.жprimalO(1)е - Check if memory for mutable unboxed array was allocated as pinned.#Documentation for utilized primop: ÷.вprimalO(1)* - Get the size of a mutable unboxed array#Documentation for utilized primop: ╗.Example.ma <- thawUArray $ fromListUArray ['a' .. 'z']getSizeOfUMArray maSize {unSize = 26}ьprimalO(1)ф - Read an element from a mutable unboxed array at the supplied index.#Documentation for utilized primop: н. Unsafe Violation of ix; preconditions can result in value that doesn't belong to srcMutArray or a failure with a segfaultExamples'ma <- thawUArray $ fromListUArray "Hi!"readUMArray ma 2'!'ыprimalO(1)ф - Write an element into an unboxed mutable array at a supplied index.#Documentation for utilized primop: я. Unsafe Violation of ixй preconditions can result in heap corruption or a failure with a segfaultExamplesimport Data.Prim4ma <- newRawUMArray 4 :: IO (UMArray (Maybe Int) RW)1mapM_ (\i -> writeUMArray ma i Nothing) [0, 1, 3]writeUMArray ma 2 (Just 2)freezeUMArray ma'UArray [Nothing,Nothing,Just 2,Nothing]зprimalO(sz)2 - Allocate new mutable unboxed array. Similar to Ющ, except all elements are initialized to the supplied initial value. This is equivalent to makeUMArray sz (const (pure a))" but often will be more efficient. UnsafeWhen any of preconditions for szч argument is violated the outcome is unpredictable. One possible outcome is termination with С async exception.Examplesimport Data.Primlet xs = "Hello"цma <- newUMArray (Size (length xs) + 8) '!' :: IO (UMArray Char RW)5mapM_ (\(i, x) -> writeUMArray ma i x) (zip [0..] xs)freezeUMArray maUArray "Hello!!!!!!!!"шprimalSame з%, but allocate memory as pinned. See А for more info. Unsafe- Same reasons as з.эprimalSame з2, but allocate memory as pinned and aligned. See Б for more info. Unsafe- Same reasons as з.щprimal┤Create new mutable unboxed array of the supplied size and fill it with a monadic action that is applied to indices of each array cell. UnsafeSame reasons as зExamplesЮma <- makeUMArray 5 $ \i -> (toEnum (i + 97) :: Char) <$ putStrLn ("Handling index: " ++ show i)Handling index: 0Handling index: 1Handling index: 2Handling index: 3Handling index: 4freezeUMArray maUArray "abcde"чprimalSame as щ , but allocate memory as pinned. UnsafeSame reasons as зъprimalSame as щ,, but allocate memory as pinned and aligned. UnsafeSame reasons as зЮprimalO(1)Ы - Allocate new mutable unboxed array. None of the elements are initialized so expect it to contain some random garbage.#Documentation for utilized primop: °. UnsafeWhen any of preconditions for szч argument is violated the outcome is unpredictable. One possible outcome is termination with С ц async exception. In a pure setting, such as when executed within иґ, if each cell in new array is not overwritten it can lead to violation of referential transparency, because contents of newly allocated unboxed array is non-determinstic.Examplesimport Data.Primlet xs = "Hello Haskell">ma <- newRawUMArray (Size (length xs)) :: IO (UMArray Char RW)5mapM_ (\(i, x) -> writeUMArray ma i x) (zip [0..] xs)freezeUMArray maUArray "Hello Haskell"АprimalO(1) - Same as Ю4 except allocate new mutable unboxed array as pinned#Documentation for utilized primop: ². UnsafeSame reasons as in Ю.БprimalO(1) - Same as Ас except allocate new mutable unboxed array as pinned and aligned according to the б" instance for the type of element e#Documentation for utilized primop: ·. UnsafeSame reasons as in Ю.ЦprimalO(sz)С - Copy a subsection of a mutable array into a subsection of another or the same mutable array. Therefore, unlike √?, memory ia allowed to overlap between source and destination.#Documentation for utilized primop: ┘. Unsafe"When any of the preconditions for srcStartIx, dstStartIx or szу is violated this function can result in a copy of some data that doesn't belong to srcArray or failure with a segfault.ДprimalO(n)# - Write the same element into the dstMutArray mutable array n times starting at dstStartIx offset. UnsafeЕprimalO(1). - Reduce the size of a mutable unboxed array.#Documentation for utilized primop: ё. Unsafe!- Violation of preconditions for sz leads to undefined behavior 3.0ФprimalO(1)Ж - Either grow or shrink the size of a mutable unboxed array. Shrinking happens without new allocation and data copy, while growing the array is implemented with allocation of new unpinned array and copy of the data over from the source array srcMutArray-. This has a consequence that produced array dstMutArray might refer to the same srcMutArray7 or to a totally new array, which can be checked with у.&Documentation on the utilized primop: є. Unsafe- Same reasons as in Ю. When size sz is larger then the size of srcMutArray then dstMutArrayГ will contain uninitialized memory at its end, hence a potential problem for referential transparency. 3.0ГprimalO(1)> - Convert a mutable unboxed array into an immutable one. Use о+ in order to go in the opposite direction.&Documentation on the utilized primop: ╔. UnsafeяThis function makes it possible to break referential transparency, because any subsequent destructive operation to the source mutable boxed array will also be reflected in the resulting immutable array. See ╘1 that avoids this problem with fresh allocation.Хprimal'Default "raw" element for boxed arrays.Иprimal!Convert a list to a mutable arrayЙprimal$Helper for generating mutable arraysКprimal╗Right fold that is strict on the element. The key feature of this function is that it can be used to convert an array to a list by integrating with list fusion using .Лprimal Check for equality of two arraysМprimal+Compare two arrays using supplied functionsНprimal3Append two arrays together using supplied functionsОprimal4Concat many arrays together using supplied functionsЭprimalЩprimalЧprimalщCheck if both of the arrays refer to the exact same one. None of the elements are evaluated.┼primal▀primal▄primalщCheck if both of the arrays refer to the exact same one. None of the elements are evaluated.▒primalO(1) - ┘ is always in NF∙primalO(1) - ┐ is always in NF√primalУCheck if both of the arrays refer to the exact same one through poiner equality. None of the elements are evaluated..■primalarray( - Array where to lookup an element fromprimalix& - Position of the element within the array Precoditions:0 <= ix ix < unSize (sizeOfBArray array)∙primalsrcArray - Immutable source arrayprimalstartIx - Location within srcArray- where the copy of elements should start fromPreconditions:0 <= startIx(startIx < unSize (sizeOfBArray srcArray)primalsz² - Size of the returned immutable array. Also this is the number of elements that will be copied over into the destionation array starting at the beginning.Preconditions:0 <= sz4startIx + unSize sz < unSize (sizeOfBArray srcArray)/Should be less then the actual available memory√primalsrcArray - Source immutable array Precondition:=srcMutArray <- thawBArray srcArray srcMutArray /= dstMutArrayprimal srcStartIxф - Offset into the source immutable array where copy should start fromPreconditions:0 <= srcStartIx+srcStartIx < unSize (sizeOfBArray srcArray)primaldstMutArray - Destination mutable arrayprimal dstStartIxл - Offset into the destination mutable array where the copy should start atPreconditions:0 <= dstStartIxцdstSize <- getSizeOfBMArray dstMutArray dstStartIx < unSize dstSizeprimalsz" - Number of elements to copy overPreconditions:0 <= sz7srcStartIx + unSize sz < unSize (sizeOfBArray srcArray)оdstSize <- getSizeOfBMArray dstMutArray dstStartIx + unSize sz < unSize dstSize≈primalarray- - Source immutable array that will be thawed≤primalsrcArray - Immutable source arrayprimalstartIx - Location within srcArray- where the copy of elements should start fromPreconditions:0 <= startIx(startIx < unSize (sizeOfBArray srcArray)primalsz⌡ - Size of the returned mutable array. Also this is the number of elements that will be copied over into the destionation array starting at the beginning.Preconditions:0 <= sz4startIx + unSize sz < unSize (sizeOfBArray srcArray)/Should be less then the actual available memoryprimaldstMutArray0 - Newly created destination mutable boxed array primalsz& - Expected number of elements in the listprimallist& - A list to bew loaded into the array═primalsrcMutArray - Array to read an element fromprimalix: - Index that refers to an element we need within the the srcMutArray Precoditions:0 <= ix'ix < unSize (sizeOfMBArray srcMutArray)║primaldstMutArray* - An array to have the element written toprimalix - Index within the the dstMutArray* that a refernce to the supplied element elt will be written to. Precoditions:0 <= ix$ix < unSize (sizeOfMBArray srcArray)primalelt - Element to be written into dstMutArrayєprimalsz - Size of the arrayPreconditions:0 <= szСShould be below some upper limit that is dictated by the operating system and the total amount of available memoryprimalelt# - Value to use for all array cells╘primalsrcArray - Source mutable arrayprimalstartIx - Location within srcArray- where the copy of elements should start fromPreconditions:0 <= startIx(startIx < unSize (sizeOfBArray srcArray)primalsz² - Size of the returned immutable array. Also this is the number of elements that will be copied over into the destionation array starting at the beginning.Preconditions:0 <= sz4startIx + unSize sz < unSize (sizeOfBArray srcArray)+Should be less then actual available memory╙primalsrcArray - Source mutable arrayprimalstartIx - Location within srcArray- where the copy of elements should start fromPreconditions:0 <= startIx(startIx < unSize (sizeOfBArray srcArray)primalsz⌡ - Size of the returned mutable array. Also this is the number of elements that will be copied over into the destionation array starting at the beginning.Preconditions:0 <= sz4startIx + unSize sz < unSize (sizeOfBArray srcArray)+Should be less then actual available memory╚primalmutArray% - Mutable unboxed array to be shrunkprimalsz/ - New size for the array in number of elementsPreconditions:0 <= sz2curSize <- getSizeOfBMArray mutArray sz <= curSize╛primalsrcMutArray# - Mutable boxed array to be shrunkprimalsz/ - New size for the array in number of elementsPreconditions:0 <= szСShould be below some upper limit that is dictated by the operating system and the total amount of available memoryprimaleltг - Element to write into extra space at the end when growing the array.primaldstMutArray! - produces a resized version of srcMutArray.ґprimalsrcMutArray# - Mutable boxed array to be shrunkprimalsz/ - New size for the array in number of elementsPreconditions:0 <= szСShould be below some upper limit that is dictated by the operating system and the total amount of available memoryprimaldstMutArray! - produces a resized version of srcMutArray.ўprimalsrcMutArray - Source mutable arrayprimal srcStartIxд - Offset into the source mutable array where copy should start fromPreconditions:0 <= srcStartIxцsrcSize <- getSizeOfBMArray srcMutArray srcStartIx < unSize srcSizeprimaldstMutArray - Destination mutable arrayprimal dstStartIxг - Offset into the destination mutable array where copy should start toPreconditions:0 <= dstStartIxцdstSize <- getSizeOfBMArray dstMutArray dstStartIx < unSize dstSizeprimalsz" - Number of elements to copy overPreconditions:0 <= szоsrcSize <- getSizeOfBMArray srcMutArray srcStartIx + unSize sz < unSize srcSizeоdstSize <- getSizeOfBMArray dstMutArray dstStartIx + unSize sz < unSize dstSize╠primalarray( - Array where to lookup an element fromprimalix& - Position of the element within the array Precoditions:0 <= ix!ix < unSize (sizeOfSBArray array)╡primalsrcArray - Immutable source arrayprimalstartIx - Location within srcArray- where the copy of elements should start fromPreconditions:0 <= startIx)startIx < unSize (sizeOfSBArray srcArray)primalsz² - Size of the returned immutable array. Also this is the number of elements that will be copied over into the destionation array starting at the beginning.Preconditions:0 <= sz5startIx + unSize sz < unSize (sizeOfSBArray srcArray)/Should be less then the actual available memoryЁprimalmutArray% - Mutable unboxed array to be shrunkprimalsz/ - New size for the array in number of elementsPreconditions:0 <= sz3curSize <- getSizeOfSBMArray mutArray sz <= curSizeЄprimalsrcMutArray# - Mutable boxed array to be shrunkprimalsz/ - New size for the array in number of elementsPreconditions:0 <= szСShould be below some upper limit that is dictated by the operating system and the total amount of available memoryprimaleltг - Element to write into extra space at the end when growing the array.primaldstMutArray! - produces a resized version of srcMutArray.╣primalsrcMutArray# - Mutable boxed array to be shrunkprimalsz/ - New size for the array in number of elementsPreconditions:0 <= szСShould be below some upper limit that is dictated by the operating system and the total amount of available memoryprimaldstMutArray! - produces a resized version of srcMutArray.ІprimalsrcArray - Source immutable array Precondition:>srcMutArray <- thawSBArray srcArray srcMutArray /= dstMutArrayprimal srcStartIxф - Offset into the source immutable array where copy should start fromPreconditions:0 <= srcStartIx,srcStartIx < unSize (sizeOfSBArray srcArray)primaldstMutArray - Destination mutable arrayprimal dstStartIxл - Offset into the destination mutable array where the copy should start atPreconditions:0 <= dstStartIxдdstSize <- getSizeOfSBMArray dstMutArray dstStartIx < unSize dstSizeprimalsz" - Number of elements to copy overPreconditions:0 <= sz8srcStartIx + unSize sz < unSize (sizeOfSBArray srcArray)пdstSize <- getSizeOfSBMArray dstMutArray dstStartIx + unSize sz < unSize dstSizeЇprimalarray- - Source immutable array that will be thawed╦primalsrcArray - Immutable source arrayprimalstartIx - Location within srcArray- where the copy of elements should start fromPreconditions:0 <= startIx)startIx < unSize (sizeOfSBArray srcArray)primalsz⌡ - Size of the returned mutable array. Also this is the number of elements that will be copied over into the destionation array starting at the beginning.Preconditions:0 <= sz5startIx + unSize sz < unSize (sizeOfSBArray srcArray)/Should be less then the actual available memoryprimaldstMutArray0 - Newly created destination mutable boxed array╨primalsz& - Expected number of elements in the listprimallist& - A list to bew loaded into the arrayЎprimalsrcMutArray - Array to read an element fromprimalix: - Index that refers to an element we need within the the srcMutArray Precoditions:0 <= ix(ix < unSize (sizeOfMSBArray srcMutArray)©primaldstMutArray* - An array to have the element written toprimalix - Index within the the dstMutArray* that a refernce to the supplied element elt will be written to. Precoditions:0 <= ix%ix < unSize (sizeOfMSBArray srcArray)primalelt - Element to be written into dstMutArrayбprimalsz - Size of the arrayPreconditions:0 <= szСShould be below some upper limit that is dictated by the operating system and the total amount of available memoryprimalelt# - Value to use for all array cellsгprimalsrcArray - Source mutable arrayprimalstartIx - Location within srcArray- where the copy of elements should start fromPreconditions:0 <= startIx)startIx < unSize (sizeOfSBArray srcArray)primalsz² - Size of the returned immutable array. Also this is the number of elements that will be copied over into the destionation array starting at the beginning.Preconditions:0 <= sz5startIx + unSize sz < unSize (sizeOfSBArray srcArray)+Should be less then actual available memoryхprimalsrcArray - Source mutable arrayprimalstartIx - Location within srcArray- where the copy of elements should start fromPreconditions:0 <= startIx)startIx < unSize (sizeOfSBArray srcArray)primalsz⌡ - Size of the returned mutable array. Also this is the number of elements that will be copied over into the destionation array starting at the beginning.Preconditions:0 <= sz5startIx + unSize sz < unSize (sizeOfSBArray srcArray)+Should be less then actual available memoryиprimalsrcMutArray - Source mutable arrayprimal srcStartIxд - Offset into the source mutable array where copy should start fromPreconditions:0 <= srcStartIxдsrcSize <- getSizeOfSBMArray srcMutArray srcStartIx < unSize srcSizeprimaldstMutArray - Destination mutable arrayprimal dstStartIxг - Offset into the destination mutable array where copy should start toPreconditions:0 <= dstStartIxдdstSize <- getSizeOfSBMArray dstMutArray dstStartIx < unSize dstSizeprimalsz" - Number of elements to copy overPreconditions:0 <= szпsrcSize <- getSizeOfSBMArray srcMutArray srcStartIx + unSize sz < unSize srcSizeпdstSize <- getSizeOfSBMArray dstMutArray dstStartIx + unSize sz < unSize dstSizeмprimalarray( - Array where to lookup an element fromprimalix& - Position of the element within the array Precoditions:0 <= ix ix < unSize (sizeOfUArray array)нprimalsrcArray - Source immutable array Precondition:=srcMutArray <- thawUArray srcArray srcMutArray /= dstMutArrayprimal srcStartIxф - Offset into the source immutable array where copy should start fromPreconditions:0 <= srcStartIx+srcStartIx < unSize (sizeOfUArray srcArray)primaldstMutArray - Destination mutable arrayprimal dstStartIxл - Offset into the destination mutable array where the copy should start atPreconditions:0 <= dstStartIxцdstSize <- getSizeOfMUArray dstMutArray dstStartIx < unSize dstSizeprimalsz" - Number of elements to copy overPreconditions:0 <= sz7srcStartIx + unSize sz < unSize (sizeOfUArray srcArray)оdstSize <- getSizeOfMUArray dstMutArray dstStartIx + unSize sz < unSize dstSizeяprimalsz& - Expected number of elements in the listprimallist& - A list to bew loaded into the arrayьprimalsrcMutArray - Array to read an element fromprimalix0 - Index for the element we need within the the srcMutArray Precoditions:0 <= ix;srcSize <- getSizeOfMUArray srcMutArray ix < unSize srcSizeзprimalsz+ - Size of the array in number of elements.Preconditions:0 <= sz Susceptible to integer overflow:.0 <= toByteCount (Count (unSize n) :: Count e)СShould be below some upper limit that is dictated by the operating system and the total amount of available memoryЮprimalsz+ - Size of the array in number of elements.Preconditions:0 <= sz Susceptible to integer overflow:.0 <= toByteCount (Count (unSize n) :: Count e)СShould be below some upper limit that is dictated by the operating system and the total amount of available memoryЦprimalsrcMutArray - Source mutable arrayprimal srcStartIxд - Offset into the source mutable array where copy should start fromPreconditions:0 <= srcStartIxцsrcSize <- getSizeOfMUArray srcMutArray srcStartIx < unSize srcSizeprimaldstMutArray - Destination mutable arrayprimal dstStartIxг - Offset into the destination mutable array where copy should start toPreconditions:0 <= dstStartIxцdstSize <- getSizeOfMUArray dstMutArray dstStartIx < unSize dstSizeprimalsz" - Number of elements to copy overPreconditions:0 <= szоsrcSize <- getSizeOfMUArray srcMutArray srcStartIx + unSize sz < unSize srcSizeоdstSize <- getSizeOfMUArray dstMutArray dstStartIx + unSize sz < unSize dstSizeДprimaldstMutArray - Mutable arrayprimal dstStartIx - Offset into the mutable arrayPreconditions:0 <= dstStartIxцdstSize <- getSizeOfMUArray dstMutArray dstStartIx < unSize dstSizeprimaln" - Number of elements to overwritePreconditions:0 <= nнdstSize <- getSizeOfMUArray dstMutArray dstStartIx + unSize n < unSize dstSizeprimalelt; - Value to overwrite the cells with in the specified blockЕprimalmutArray% - Mutable unboxed array to be shrunkprimalsz/ - New size for the array in number of elementsPreconditions:0 <= sz2curSize <- getSizeOfUMArray mutArray sz <= curSizeФprimalsrcMutArray% - Mutable unboxed array to be shrunkprimalsz/ - New size for the array in number of elementsPreconditions:0 <= sz Susceptible to integer overflow:.0 <= toByteCount (Count (unSize n) :: Count e)СShould be below some upper limit that is dictated by the operating system and the total amount of available memoryprimaldstMutArray! - produces a resized version of srcMutArray.ХprimalModule nameprimal Function nameИprimalFunction for array creationprimalFunction for writing elementsprimalSize for the created arrayprimal1Function for generating elements from array indexЙprimalFunction for array creationprimalFunction for writing elementsprimalSize for the created arrayprimal1Function for generating elements from array indexКprimal+Function that produces the size of an arrayprimalIndexing functionprimalFolding functionsprimalInitial accumulatorprimalArray to fold overЛprimalPointer equalityprimalGet the size of arrayprimalIndex an element of an arrayprimalFirst arrayprimalSecond arrayМprimalPointer equalityprimalGet the size of arrayprimalIndex an element of an arrayprimalFirst arrayprimalSecond arrayМ┐└┘├┤┬┴┼▀▄█▌▐░▒▓⌠■∙√≈≤≥ ⌡°²·÷═║╒ёє╔ії╗╘╙╚╛ґў╞╟╠╡ЁЄ╣ІЇ╦╧╨╩╪ҐЎ©юабцдефгхийклмнопярстужвьызшэщчъЮАБЦДЕФГХИЙКЛМНОМ▐░▒█▌▓⌠■√∙≈≤≥⌡ °²▀▄÷═║╒ё·є╔іїў╙╚╛ґ╗╘┴┼╞╟╠І╡Ї╦╧╩╨┤┬╪ҐЎ©юабцдеихЁЄ╣фг┘├йклмнопряст┐└ужвьызЮщшАчэБъЦДЕФГХЙИКЛМНО (c) Alexey Kuleshevich 2020BSD3(Alexey Kuleshevich experimentalnon-portableNone?гу|╗primalЦFind the offset in bytes that is between the two pointers by subtracting one address from another.╘primal╒Find 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.╞primalМCompare 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 B= at the supplied index. Returns the artifact of computation bж. 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 B= at the supplied index. Returns the artifact of computation bж. 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 BМ 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 B┴ 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 BМ 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 B, 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 B, 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 B, 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 B, 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 B* 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 B* 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 B* 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 B* 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 B* 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 B* 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 B* 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 B* 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 B, 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 B, 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 with╠primalArray to be mutatedprimalIndex is in elements of a, rather than bytes.primalExpected old valueprimal New value╡primalArray to be mutatedprimalIndex is in elements of a, rather than bytes.primalБFunction that is applied to the old value and returns new value and some artifact of computation bЁprimalArray 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.primalцFunction that is applied to the old value and returns the new value╣primalArray to be mutatedprimalIndex is in elements of a, rather than bytes.primalцFunction that is applied to the old value and returns the new valueцBцCдґў╞╟╡╠ЄЁ╨╩╪ҐЎ©юаб÷═║╒ёє╔ії╗╘╙╚╛ґў╞╟╠╡ЁЄ╣ІЇ╦╧╨╩╪ҐЎ©юабцдефгхийклаїі╘╙╗є═║╔╒ё÷╚╛ґў╞╟лBC╨╩╪ҐЎ©юаб╡╠╟╞ЄЁўґ╠╡ЁЄ╣ІЇ╦╧╨╩╪ҐЎ©юабцдефгхийк(c) Alexey Kuleshevich 2020BSD3(Alexey Kuleshevich experimentalnon-portableNone?в╛мprimalSame as Ў, but generalized to ЪнprimalSame as ©, but generalized to ЪоprimalSame as ю, but generalized to Ъ1╧Ї╦мно1╧мно╦Ї(c) Alexey Kuleshevich 2020BSD3(Alexey Kuleshevich experimentalnon-portableNone?гэI рprimalSame as @Aв, except it requires a finalizer to be supplied. For a version without finalizers use ссprimalSimilar to р), except it does not require a finalizer.тprimalSame as @Bв, except it requires a finalizer to be supplied. For a version without finalizers use ууprimalSimilar to т), except it does not require a finalizer.жprimalSame as @C.вprimal7Add a foreign function finalizer with a single argumentьprimal3Add a foreign function finalizer with two argumentsыprimalSimilar to @DзprimalSimilar to @EвprimalхPointer to the C function to be called when finalizers are being invokedprimal8Argument that will be supplied to the finalizer functionьprimalхPointer 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хгрстужвьызхгрстужвьыз(c) Alexey Kuleshevich 2020BSD3(Alexey Kuleshevich experimentalnon-portableNone?гивыЗ²%шprimalCompatibility synonymэprimalCompatibility synonymщprimal modifyFetchOldRef ref2 (* x))readRef ref1201readRef ref22010ОprimalЩApply a pure function to the contents of a mutable variable lazily. Returns the artifact produced by the modifying function.ПprimalФModify value of a mutable variable with a monadic action. It is not strict in a return value of type bк, but the ne value written into the mutable variable is evaluated to WHNF.ExamplesЯprimalSame as Пз, except evaluates new value to normal form prior ot it being written to the mutable ref.РprimalуModify value of a mutable variable with a monadic action. Result is written strictly.Examples!ref <- newRef (Just "Some value")6modifyRefM_ ref $ \ mv -> Nothing <$ mapM_ putStrLn mv Some valuereadRef refNothingСprimalщApply a monadic action to the contents of a mutable variable strictly. Returns the old value.Examples refName <- newRef "My name is: "refMyName <- newRef "Alexey"ьmyName <- modifyFetchOldRefM refMyName $ \ name -> "Leo" <$ modifyRef_ refName (++ name)readRef refName >>= putStrLnMy name is: AlexeyputStrLn myNameAlexeyreadRef refMyName >>= putStrLnLeoТprimalщApply a monadic action to the contents of a mutable variable strictly. Returns the new value.УprimalSame as П5, but do not evaluate the new value written into the щ.Жprimal0Evaluate a value and write it atomically into a щ. This is different from Г because ,https://en.wikipedia.org/wiki/Memory_barriera memory barrier& will be issued. Use this instead of Го in order to guarantee the ordering of operations in a concurrent environment.Вprimal%This will behave exactly the same as Ц when the щҐ is accessed within a single thread only. However, despite being slower, it can help with with restricting order of operations in cases when multiple threads perform modifications to the щ& because it implies a memory barrier.ЬprimalSame as Ж!, but also returns the old value.Ыprimal2Apply a function to the value stored in a mutable щУ atomically. Function is applied strictly with respect to the newly returned value, which matches the semantics of atomicModifyIORefь`, however the difference is that the artifact returned by the action is not evaluated.Example┐primal(Appy a function to the value in mutable щ atomically▄primalConvert щ to ш█primalConvert ш to щ▌primalConvert щ to э▐primalConvert э to щ░primal Create a х& pointer associated with the supplied щ.Same as IJ from base, but works in any Ъ with / state token.▒primalUses ъ░primal*An action that will get executed whenever щ( gets garbage collected by the runtime.6шэщчъЮАБЦДЕФГХИЙКЛМНОПЯРСТУЖВЬЫЗШЭЩЧЪ─│┌┐└┘├┤┬┴┼▀▄█▌▐░6щчэшЮАъЦДФГХЙКЛМНПЯРТСВЬЖЫШ┐ЪЩ│├ЗЭ─Ч┌└БИЕОУ▀┬┼┴┘┤▄█▌▐░аKLMKLNOPQOPROPSOPTOPUOVWOVXOVYKLZKL[OV\K]OP^OP_K`aKbKcKdKeOPfKLgKLhKLiKjkK`lKLmOPnOPoOPpOPqOrsOPtOruOPvOrwOPxOryOPzOP{OP|OP}OP~OPOP─OP│OP┌OP┐K└┘Or├OP┤OP┬OP┴OP┼OP▀Or▄OP█OP▌Or▐OP░OP▒OP▓OP⌠OP■OP∙K√≈K√≤OP≥OP Or⌡Or°Or²Or·Or÷OP═Or║OP╒OPёKє╔OPіOPїOP╗OP╘OP╙OP╚OP╛OPґOPўOP╞OP╟OP╠OP╡OPЁOPЄOP╣OPІOPЇOP╦OP╧OP╨OP╩OP╪OPҐOPЎOP©OPюOPаOPбOPцOrдOrеOrфOrгOrхOr▄KєиOrйOrкOrлOrмOrнOrоOrпOrяOrрOrсOrтOrуOrжOrвOrьOrыOrзOrшOrэOrщOrчOrъOrЮOrАOrБOrЦOrДOrЕOrФOrГOrХOrИOrЙOrКOPЛOPМOPНOPОOPПOPЯOPРOPСOPТOPУOPЖOPВOPЬOPЫOPЗOPШOPЭOPЩOPЧOPЪOP─OP│OP┌OP┐OP└OP┘OP├OP┤OP┬OP┴OP┼OP▀OP▄OP█OP▌OP▐OP░OP▒OP▓OP⌠OP■OP∙OP√OP≈OP≤OP≥OP OP⌡OP°OP²OP·OP÷OP═OP║OP╒OPёOPєOP╔OPіOPїOP╗OP╘OP╙OP╚OP╛OPґOPўOP╞OP╟OP╠OP╡OPЁOPЄOP╣OPІOPЇOP╦OP╧OP╨OP╩OP╪OPҐOPЎOP©OPюOPаOPбOPцOPдOPеOPфOPгOPхOPиOPйOPкOPлOPмOPнOPоOPпOPяOPрOPсOPтOPуOPжOPвOPьOPыOPзOPшOPэOPщOPчOPъOPЮOPАOPБOPЦOPДOPЕOPФOPГOPХOPИOPЙOPКOPЛOPМOPНOPОOPПOPЯOPРOPСOPТOPУOPЖOPВOPЬOPЫOPЗOPШOPЭOPЩOPЧOPЪOP─OP│OP┌OP┐OP└OP┘OP├OP┤OP┬OP┴OP┼OP▀OP▄OP█OP▌OP▐OP░OP▒OP▓OP⌠OP■OP∙OP√OP≈OP≤OP≥OP OP⌡OP°OP²OP·OP÷OP═OP║OP╒OPёOPєOP╔OPіOPїOP╗OP╘OP╙OP╚OP╛OPґOPўOP╞OP╟OP╠OP╡OPЁOPЄOP╣OPІOPЇOP╦OP╧OP╨OP╩OP╪OPҐOPЎOP©OPюOPаOPбOPцOPдOPеOPфOPгOPхOPиOPйOPкOPлOPмOPнOPоOPпOPяOPрOPсOPтOPуOPжOPвOPьOPыOPзOPшOPэOPщOPчOPъOPЮOPАOPБOPЦOPДOPЕOPФOPГOPХOPИOPЙOPКOPЛOPМOPНOPОOPПOPЯOPРOPСOPТOPУOPЖOPВOPЬOPЫOPЗOPШOPЭOPЩOPЧOPЪOP─OP│OP┌OP┐OP└OP┘OP├OP┤OP┬OP┴OP┼OP▀OP▄OP█OP▌OP▐OP░OP▒OP▓OP⌠OP■OP∙OP√OP≈OP≤OP≥OP OP⌡OP°OP²OP·OP÷OP═OP║OP╒OPёOPєOP╔OPіOPїOP╗OP╘OP╙OP╚OP╛OPґOPўOP╞OP╟OP╠OP╡OPЁOPЄOP╣OPІOPЇOP╦OP╧OP╨OP╩OP╪OPҐOPЎOP©OPюOPаOPбOPцOPдOPеOPфOPгOPхOPиOPйOPкOPлOPмOPнOPоOPпOPяOPрOPсOPтOPуOPжOPвOPьOPыOPзOPшOPэOPщOPчOPъOPЮOPАOPБOPЦOPДOPЕOPФOPГOPХOPИOPЙOPКOPЛOPМOPНOPОOPПOPЯOPРOPСOPТOPУOPЖOPВOPЬOPЫOPЗOPШOPЭOPЩOPЧOPЪOP─OP│OP┌OP┐OP└OP┘OP├OP┤OP┬OP┴OP┼OP▀OP▄OP█OP▌OP▐OP░OP▒OP▓OP⌠OP■OP∙OP√OP≈OP≤OP≥OP OP⌡OP°OP²OP·OP÷OP═OP║OP╒OPёOPєOP╔OPіOPїOP╗OP╘OP╙OP╚OP╛OPґOPўOP╞OP╟OP╠OP╡OPЁOPЄOP╣OPІOPЇOP╦OP╧OP╨OP╩OP╪OPҐOPЎOP©OPюOPаOPбOPцOPдOPеOPфOPгOPхOPиOPйOPкOPлOPмOPнOPоOPпOPяOPрOPсOPтOPуOPжOPвOPьOPыOPзOPшOPэOPщOPчOPъOPЮOPАOPБOPЦOPДOPЕOPФOPГOPХOPИOPЙOPКOPЛOPМOPНOPОOPПOPЯOPРOPСOPТOPУOPЖOPВOPЬOPЫOPЗOPШOPЭOPЩOPЧOPЪOP─OP│OP┌OP┐OP└OP┘OP├OP┤OP┬OP┴OP┼OP▀OP▄OP█OP▌OP▐OP░OP▒OP▓OP⌠OP■OP∙OP√OP≈OP≤OP≥OP OP⌡OP°OP²OP·OP÷OP═OP║OP╒OPёOPєOP╔OPіOPїOP╗OP╘OP╙OP╚OP╛OPґOPўOP╞OP╟OP╠OP╡OPЁOPЄOP╣OPІOPЇOP╦OP╧OP╨OP╩OP╪OPҐOPЎOP©OPюOPаOPбOPцOPдOPеOPфOPгOPхOPиOPйOPкOPлOPмOPнOPоOPпOPяOPрOPсOPтOPуOPжOPвOPьOPыOPзOPшOPэOPщOPчOPъOPЮOPАOPБOPЦOPДOPЕOPФOPГOPХOPИOPЙOPКOPЛOPМOPНOPОOPПOPЯOPРOPСOPТOPУOPЖOPВOPЬOPЫOPЗOPШOPЭOPЩOPЧOPЪOP─OP│OP┌OP┐OP└OP┘OP├OP┤OP┬OP┴OP┼OP▀OP▄OP█OP▌OP▐OP░OP▒OP▓OP⌠OP■OP∙OP√OP≈OP≤OP≥OP OP⌡OP°OP²OP·OP÷OP═OP║OP╒OPёOPєOP╔OPіOPїOP╗OP╘OP╙OP╚OP╛OPґOPўOP╞OP╟OP╠OP╡OPЁOPЄOP╣OPІOPЇOP╦OP╧OP╨OP╩OP╪OPҐOPЎOP©OPюOPаOPбOPцOPдOPеOPфOPгOPхOPиOPйOPкOPлOPмOPнOPоOPпOPяOPрOPсOPтOPуOPжOPвOPьOPыOPзOPшOPэOPщOPчOPъOPЮOPАOPБOPЦOPДOPЕOPФOPГOPХOPИOPЙOPКOPЛOPМOPНOPОOPПOPЯOPРOPСOPТOPУOPЖOPВOPЬOPЫOPЗOPШOPЭOPЩOPЧOPЪOP─OP│OP┌OP┐OP└OP┘OP├OP┤OP┬OP┴OP┼OP▀OP▄OP█OP▌OP▐OP░OP▒OP▓OP⌠OP■OP∙OP√OP≈OP≤OP≥OP OP⌡OP°OP²OP·OP÷OP═OP║OP╒OPёOPєOP╔OPіOPїOP╗OP╘OP╙OP╚OP╛OPґOPўOP╞OP╟OP╠OP╡OPЁOPЄOP╣OPІOPЇOP╦OP╧OP╨OP╩OP╪OPҐOPЎOP©OPюOPаOPбOPцOPдOPеOPфOPгOPхOPиOPйOPкOPлOPмOPнOPоOPпOPяOPрOPсOPтOPуOPжOPвOPьOPыOPзOPшOPэOPщOPчOPъOPЮOPАOPБOPЦOPДOPЕOPФOPГOPХOPИOPЙOPКOPЛOPМOPНOPОOPПOPЯOPРOPСOPТOPУOPЖOPВOPЬOPЫOPЗOPШOPЭOPЩOPЧOPЪOP─ OP│ OP┌ OP┐ OP└ OP┘ OP├ OP┤ OP┬ OP┴ OP┼ OP▀ OP▄ OP█ OP▌ OP▐ OP░ OP▒ OP▓ OP⌠ OP■ OP∙ OP√ OP≈ OP≤ OP≥ OP OP⌡ OP° OP² OP· OP÷ OP═ OP║ OP╒ OPё OPє OP╔ OPі OPї OP╗ OP╘ OP╙ OP╚ OP╛ OPґ OPў OP╞ OP╟ OP╠ OP╡ OPЁ OPЄ OP╣ OPІ OPЇ OP╦ OP╧ OP╨ OP╩ OP╪ OPҐ OPЎ OP© OPю OPа OPб OPц OPд OPе OPф OPг OPх OPи OPй OPк OPл OPм OPн OPо OPп OPя OPр OPс OPт OPу OPж OPв OPь OPы OPз OPш OPэ OPщ OPч OPъ OPЮ OPА OPБ OPЦ OPД OPЕ OPФ OPГ OPХ OPИ OPЙ OPК OPЛ OPМ OPН OPО OPП OPЯ OPР OPС OPТ OPУ OPЖ OPВ OPЬ OPЫ OPЗ OPШ OPЭ OPЩ OPЧ OPЪ OP─ OP│ OP┌ OP┐ OP└ OP┘ OP├ OP┤ OP┬ OP┴ OP┼ OP▀ OP▄ OP█ OP▌ OP▐ OP░ OP▒ OP▓ OP⌠ OP■ OP∙ OP√ OP≈ OP≤ OP≥ OP OP⌡ OP° OP² OP· OP÷ OP═ OP║ OP╒ OPё OPє OP╔ OPі OPї OP╗ OP╘ OP╙ OP╚ OP╛ OPґ OPў OP╞ OP╟ OP╠ OP╡ OPЁ OPЄ OP╣ OPІ OPЇ OP╦ OP╧ OP╨ OP╩ OP╪ OPҐ OPЎ OP© OPю OPа OPб OPц OPд OPе OPф OPг OPх OPи OPй OPк OPл OPм OPн OPо OPп OPя OPр OPс OPт OPу OPж OPв OPь OPы OPз OPш OPэ OPщ OPч OPъ OPЮ OPА OPБ OPЦ OPД OPЕ OPФ OPГ OPХ OPИ OPЙ OPК OPЛ OPМ OPН OPО OPП OPЯ OPР OPС OPТ OPУ OPЖ OPВ OPЬ OPЫ OPЗ OPШ OPЭ OPЩ OPЧ OPЪ OP─OP│OP┌OP┐OP└OP┘OP├OP┤OP┬OP┴OP┼OP▀OP▄OP█OP▌OP▐OP░OP▒OP▓OP⌠OP■OP∙OP√OP≈OP≤OP≥OP OP⌡OP°OP²K·÷K═║O╒ёO╒єO╒╔KіKїK╗K╘K╙K╚K╛KґKўK╞K╟╠K╟╡K╟ЁK╟ЁKЄ╣KІЇKІЇKІ╦KІ╦K╧╨K╧╨K╩╪K╩ҐK╩ЎK╩ЎK╩©K╩©K╩юK╩юK╩аK╩аK╩бK╩бK╩цK╩цK╩дK╩еK╩фK╩гK╩хK╩иK╩йK╩кKлмKлнKлоKлпK╩яKрсKртKруKржKруKвьKвыKвзKвшKвэKвщKвчKвъKвЮKвАKвБKЦДKЦЕKЦЕKФГKФХKФХKФИKФЙKФЙKФКKФЛKФЛKФМKФ║KФ║KФНKФОKФОKФПKФЯKФЯKФРKФСKФСKТУKТЖKТЖKВЬKВЬKЫЗKЫЗKШЭKШЩKШЧKШЪKШ─KШ─KШ│KШ│K┌┐K┌└K└┘K└├K└┘K√┤K√┬K√┴K√┼K√▀K√▄K√█K√▌K√▐K√≈K√≤K░▒K░▓K⌠■K⌠■K═∙K═║K√≈K√≤K√≥K√ K⌡°KL²KL·KL÷KL═KL║KL╒KєёKєєKє╔KєіKєїKє╗Kє╘Kє╙Kє╚KєиKв╛Orґў╞╟ ╠ ╡ Ё Є ╣ І Ї ╦ ╧ ╨ ╩ ╪ Ґ Ў © ю а б ц д е фгхийклмнопярстужвьызшэщчъъЮАБЦДЕФГХИЙКЛМНОПЯРСТУЖВЬЫЗШЭЩЧЪ─ │ ┌ ┐ └ ┘ ├ ┤ ┬ ┴ ┼ ▀ ▄ █ ▌ ▐ ░ ▒ ▓ ⌠ ■ ∙ √ ≈ !!≤ ≥ " ⌡ #$° ² %· ÷ ═ &║ ╒ '()*ё +,.є ╔ і ї ╗ /01╘ ╙ ╚ ╛ ґ ў 3╞ 3╟ 3╠ 3╡ 3Ё 3Є 3╣ 3І 3Ї 3╦ 3╧ 3╨ 3╩ 3╪ 3Ґ 3Ў 3© 3ю 3а 3б 3ц 3д 3е 3ф 3г 3х 3и 3й 3к 3л 3м 3н 3о 3п 3я 3р 3с 3т 3у 3ж 3в 3ь 3ы 3з 3ш 3э 3щ 3ч 3ъ 3Ю 3А 3Б 3Ц 3Д 3Е 3Ф 3Г 3Х 3И 3Й 3К 3Л 3М 3Н 3О 3П 3Я 3Р 3С 3Т 3У 3Ж 3В 3Ь 3Ы 3З 3Ш 3Э 3Щ 3Ч 3Ъ 3─3│3┌3┐3└3┘3├3┤3┬3┴3┼3▀3▄3█3▌3▐3░3▒3▓3⌠3■3∙3√3≈3≤3≥3 3⌡3°3²3·3÷3═3║3╒3ё3є3╔3і3ї3╗3╘3╙3╚3╛3ґ3ў3╞3╟3╠3╡3Ё3Є3╣3І3Ї3╦3╧3╨3╩3╪3Ґ3Ў3©3ю3а3б3ц3д3е3ф3г3х3и3й3к3л3м3н3о3п3я3р3с3т3у3ж3в3ь3ы3з3ш3э3щ3ч3ъ3Ю3А3Б3Ц3Д3Е3Ф3Г3Х3И3Й3К3Л3М3Н3О3П3Я3Р3С3Т3У3Ж3В3Ь3Ы3З3Ш3Э3Щ3Ч3Ъ3─3│3┌3┐3└3┘3├3┤3┬3┴3┼3▀3▄3█3▌3▐3░3▒3▓3⌠3■3∙3√3≈3≤3≥3 3⌡3°3²3·3÷3═3║3╒3ё3є3╔3і3ї3╗3╘3╙3╚3╛3ґ3ў3╞3╟3╠3╡3Ё3Є3╣3І3Ї3╦3╧3╨3╩3╪3Ґ3Ў3©3ю3а3б3ц3д3е3ф3г3х3и3й3к3л3м3н3о5п5я5р5с5т5у5ж5в5ь5ы5з5ш5э5щ5ч5ъ5Ю5А5Б5Ц5Д5Е5Ф5Г5Х5И5Й5К6Л6М6Н6О6П6Я6РСТУЖВ H Ь Ы З Ш Э Щ Ч Ъ ─ │ ┌ ┐ └ ┘ ├ ┤ ┬ ┴ ┼ ▀ ▄ █ ▌ ▐ ░ ▒ ▓ ⌠ ■ ∙ √ ≈ ≤ ≥ ⌡ ° ² · ÷ ═ ║ ╒ ё є ╔ і ї ╗ ╘ ╙ ╚ ╛ ґ ў ╞ ╟ ╠ ╡ Ё Є ╣ І Ї ╦ ╧ ╨ ╩ ╪ Ґ Ў © ю а б ц д е ф г х и й к л м н о п я р с т у ж в ь ы з ш э щ ч ъ Ю А Б Ц Д Е Ф Г Х И Й К Л М Н О П Я Р С Т У Ж В Ь Ы З ШЭЩЧЪ─│┌┐└┘├┤┬┴┼▀▄█▌▐░▒▓⌠■∙√≈≤≥ ⌡°²·÷═║╒ёє╔ії╗╘╙╚╛ґў╞╟╠╡ЁЄ╣ІЇ╦╧╨╩╪ҐЎ©юабцдефгхийклмнопярстужвьызшэщчъЮАБЦДЕФГХИЙКЛМНОПЯРСТУЖВЬЫЗШЭЩЧЪ─│┌┐└┘├┤┬┴┼▀▄█▌▐░▒▓⌠■∙√≈≤≥ ⌡°²·÷═║╒ёє╔ії╗╘╙╚╛ґў╞╟╠╡ЁЄ╣ІЇ╦╧╨╩╪9ҐЎ©юаб:цдефгхийкклмнопярстужвьызшэщчъЮАБЦДЕФГХИЙКЛМНОПЯРСТУЖВЬЫЗШЭЭЩЧЧЪ─│┌┐└┘├┤┬┴┼▀▄█▌▐░▒▓⌠■∙√≈≤≥ ⌡°²·÷═║╒ёє╔ії╗╘╙╚╛ґў╞╟╠╡ЁЁЄЄ╣╣ІІЇЇ╦╦╧╧╨╩╪ҐЎ©юабцдефгхийклмнопярстужвьызшэщчъЮАБЦДЕФГХИЙКЛМНОПЯРСТУЖВЬЫЗШЭЩЧЪ─│┌┐└┘├┤┬┴┼▀▄█▌▐░▒▓⌠■∙√≈≤≥ ⌡°²·÷═║╒ёє╔ії╗╘╙╚╛ґў╞╟╠╡ЁЄ╣ІЇ╦╧╨╩╪ҐЎ©юабцдефг х и й к л м н о п я р с т у ж в ь ы з ш э щ ч ъ Ю А Б Ц Д Е Ф Г Х И Й К Л М Н О П Я Р С Т УЖВЬЫЗAШBЭCЩЧDЪG─││┌┐└┘├┤┬┴┼▀▄█▌▐░▒▓⌠■∙√≈≤≥ ⌡°²·÷═║╒ёє╔ії╗╘╙╚╛ґў╞╟╠╡JЁЄ╣ІЄЇ╦ў╞╧ў╞╨ў╞╩ў╞╪ў╞Ґў╞Ўў╞©ў╞юў╞аў╞бў╞цў╞дKLеKфгKфхKLиKLйKLкKLлKLмKLнKLоKLпKярKясKтуKтжKфвKфьKфыKфзKфшKфэKфщKфчKфъKфЮKфАKфБKфЦKтДKЕФKЕГKЕХKЕИKЙКKLЛKLМKLНKLОKLПKLЯKLРKLСKLТKLУK√ЖKл≈ OrВOrЬKЫЗK┌ШK┌ЭK┌ЩK┌ЧK┌ЪK┌─K┌│K┌┌K░┐K░└K░┘K░├K░┤K░┬K░┴K░┼K▀▄K▀▄K▀█K▀█K▀▌K▀▌K▀▐K▀▐K▀░K▀░K▀▒K▀▒K▀▓K▀▓K▀⌠K▀⌠K▀■K▀■K▀∙K▀∙K▀√K▀√K▀≈K▀≈K▀≤K▀≤K▀≥K▀≥K▀ K▀ K▀⌡K▀⌡K▀°K▀°K▀²K▀²K▀·K▀·K▀÷K▀÷K▀═K▀═K▀║K▀║K▀╒K▀╒K▀ёK▀ёK▀єK▀╔K▀іK▀їK▀╗K▀╘K▀╙K▀╚K▀╛K▀ґK▀ўK▀╞K▀╟KЫ╠KЫ╠KЫ╡KЫ╡KЫЁKЫЁKЫЄKЫЄKЫ╣KЫ╣KЫІKЫІKЫЇKЫЇKЫ╦KЫ╦KЫ╧KЫ╧KЫ╨KЫ╨KЫ╩KЫ╩KЫ╪KЫ╪KЫҐKЫҐKЫЎKЫЎKЫ©KЫ©KЫюKЫюKЫаKЫаKЫбKЫбKЫцKЫцKЫдKЫдKЫеKЫеKЫфKЫгKЫхKЫиKЫиKЫйKЫйKЫкKЫкKЫлKЫлK┌мK┌нK┌оK┌пK┌яK┌рK┌сK┌тK┌уK┌жK┌вK┌ьK┌ыK┌зK┌шK┌эK┌щK┌чK┌ъK┌ЮK┌АK┌БK┌ЦK┌ДK░ЕK░ФK░ГK░ХK░ИK░ЙK░КK░ЛK░МK░НK░ОK░ПK░ЯK░РK░СK░ТK░УK░ЖK░ВK░ЬK░ЫK░ЗK░ШK░ЭK░ЩK░ЧK░ЪK░─K░│K░┌K░┐O└┘O└├O└┤O└┬O└┴O└┼O└▀O└▄O└█O└▌O└▐O└░K▒юK▓аKL⌠KL■KL∙KL√K≈≤K≈≥K≈ K≈⌡K≈°K≈°K≈²K≈·K≈·K≈÷K≈═K≈═K≈║K≈╒K≈ёK≈ёK≈єK≈╔K≈╔K≈іK≈їK≈╗K≈╘K≈╙K≈╙K≈╚KФ╛KФґKФўK╞╟╠╡ЄKЁЄKЁ╣KШУK└ЖK└ВK└ЬІ$primal-0.3.0.0-GhltlpugzpW2pg0rorinVForeign.PrimControl.Prim.Eval Data.PrimControl.Prim.MonadForeign.Prim.StablePtrControl.Prim.ExceptionData.Prim.StableNameControl.Prim.ConcurrentData.Prim.ClassForeign.Prim.PtrForeign.Prim.WeakPtrControl.Prim.Monad.UnsafeControl.Prim.Monad.ThrowControl.Prim.Concurrent.MVarData.Prim.AtomicData.Prim.AtomData.Prim.Array Data.Prim.RefthrowControl.Prim.Monad.InternalGHC.Extstouch#Control.ExceptionevaluateControl.Monad.ST.UnsafeunsafeSTToIOEUnsafeonExceptionmask_maskuninterruptibleMaskControl.Concurrent.MVarMVarnewMVarnewEmptyMVarputMVar tryPutMVarswapMVartakeMVartryTakeMVarreadMVartryReadMVarwithMVarwithMVarMaskedGHCmodifyMVar_ modifyMVarmodifyMVarMasked mkWeakMVarForeign.Prim.C.LtGHC802Foreign.Prim.C.AtomicForeign.Prim.C.LtGHC806Foreign.Prim.CForeign.Prim.CmmControl.ConcurrentforkIOforkOnyield Data.Bits.&. complement.|.xorSystem.Mem.WeakmkWeak mkWeakPtraddFinalizer deRefWeakfinalize Data.STRefSTRefPrim Data.IORef mkWeakRefbaseGHC.Baseaugmentbuildghc-primGHC.Primseq realWorld#void# unsafeCoerce# nullAddr# GHC.MagiclazyoneShotrunRW# breakpointbreakpointCondinline groupWith magicDictcoerceData.String fromStringIsListfromList fromListNtoListproxy#memptymappendmconcatData.Typeable.InternalTypeableIsStringMonoidAddr#Array# ByteArray#Char# GHC.TypesCharDouble#DoubleFloat#FloatInt#IntInt8#Int16#Int32#Int64#Weak# MutableArray#MutableByteArray#MVar# RealWorld StablePtr# GHC.Stable StablePtr~~ArrayArray#MutableArrayArray#State#StableName#MutVar#IOVoid#Word#WordWord8#Word16#Word32#Word64# ThreadId#BCO#GHC.PtrPtrFunPtrTVar#Compact# Constraint RuntimeRepVecCountVecElem CoercibleProxy#AnySmallArray#SmallMutableArray#GHC.Stack.Types CallStackInt8X16#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#C#D#F#I#W#SrcLocVecRepTupleRepSumRep LiftedRepUnliftedRepIntRepInt8RepInt16RepInt32RepInt64RepWordRepWord8Rep Word16Rep Word32Rep Word64RepAddrRepFloatRep DoubleRepVec2Vec4Vec8Vec16Vec32Vec64Int8ElemRepInt16ElemRepInt32ElemRepInt64ElemRepWord8ElemRep Word16ElemRep Word32ElemRep Word64ElemRepFloatElemRep DoubleElemRepgtChar#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#extendInt8#narrowInt8#negateInt8# plusInt8#subInt8# timesInt8# quotInt8#remInt8#quotRemInt8#eqInt8#geInt8#gtInt8#leInt8#ltInt8#neInt8#extendWord8#narrowWord8# notWord8# plusWord8# subWord8#timesWord8# quotWord8# remWord8# quotRemWord8#eqWord8#geWord8#gtWord8#leWord8#ltWord8#neWord8#extendInt16#narrowInt16#negateInt16# plusInt16# subInt16#timesInt16# quotInt16# remInt16# quotRemInt16#eqInt16#geInt16#gtInt16#leInt16#ltInt16#neInt16# extendWord16# narrowWord16# notWord16#plusWord16# subWord16#timesWord16#quotWord16# remWord16#quotRemWord16# eqWord16# geWord16# gtWord16# leWord16# ltWord16# neWord16# 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#bitReverse8# bitReverse16# bitReverse32# bitReverse64#bitReverse#narrow8Int#narrow16Int#narrow32Int#narrow8Word# narrow16Word# narrow32Word#>##>=##==##/=##<##<=##+##-##*##/## negateDouble#fabsDouble#double2Int# double2Float# expDouble#expm1Double# logDouble#log1pDouble#sqrtDouble# sinDouble# cosDouble# tanDouble#asinDouble#acosDouble#atanDouble#sinhDouble#coshDouble#tanhDouble#asinhDouble#acoshDouble#atanhDouble#**##decodeDouble_2Int#decodeDouble_Int64#gtFloat#geFloat#eqFloat#neFloat#ltFloat#leFloat# plusFloat#minusFloat#timesFloat#divideFloat#negateFloat# fabsFloat# float2Int# expFloat#expm1Float# logFloat#log1pFloat# sqrtFloat# sinFloat# cosFloat# tanFloat# asinFloat# acosFloat# atanFloat# sinhFloat# coshFloat# tanhFloat#asinhFloat#acoshFloat#atanhFloat#powerFloat# float2Double#decodeFloat_Int# newArray#sameMutableArray# readArray#writeArray#sizeofArray#sizeofMutableArray#indexArray#unsafeFreezeArray#unsafeThawArray# copyArray#copyMutableArray#cloneArray#cloneMutableArray#freezeArray# thawArray# casArray#newSmallArray#sameSmallMutableArray#shrinkSmallMutableArray#readSmallArray#writeSmallArray#sizeofSmallArray#sizeofSmallMutableArray#getSizeofSmallMutableArray#indexSmallArray#unsafeFreezeSmallArray#unsafeThawSmallArray#copySmallArray#copySmallMutableArray#cloneSmallArray#cloneSmallMutableArray#freezeSmallArray#thawSmallArray#casSmallArray# newByteArray#newPinnedByteArray#newAlignedPinnedByteArray#isMutableByteArrayPinned#isByteArrayPinned#byteArrayContents#sameMutableByteArray#shrinkMutableByteArray#resizeMutableByteArray#unsafeFreezeByteArray#sizeofByteArray#sizeofMutableByteArray#getSizeofMutableByteArray#indexCharArray#indexWideCharArray#indexIntArray#indexWordArray#indexAddrArray#indexFloatArray#indexDoubleArray#indexStablePtrArray#indexInt8Array#indexInt16Array#indexInt32Array#indexInt64Array#indexWord8Array#indexWord16Array#indexWord32Array#indexWord64Array#indexWord8ArrayAsChar#indexWord8ArrayAsWideChar#indexWord8ArrayAsAddr#indexWord8ArrayAsFloat#indexWord8ArrayAsDouble#indexWord8ArrayAsStablePtr#indexWord8ArrayAsInt16#indexWord8ArrayAsInt32#indexWord8ArrayAsInt64#indexWord8ArrayAsInt#indexWord8ArrayAsWord16#indexWord8ArrayAsWord32#indexWord8ArrayAsWord64#indexWord8ArrayAsWord#readCharArray#readWideCharArray# readIntArray#readWordArray#readAddrArray#readFloatArray#readDoubleArray#readStablePtrArray#readInt8Array#readInt16Array#readInt32Array#readInt64Array#readWord8Array#readWord16Array#readWord32Array#readWord64Array#readWord8ArrayAsChar#readWord8ArrayAsWideChar#readWord8ArrayAsAddr#readWord8ArrayAsFloat#readWord8ArrayAsDouble#readWord8ArrayAsStablePtr#readWord8ArrayAsInt16#readWord8ArrayAsInt32#readWord8ArrayAsInt64#readWord8ArrayAsInt#readWord8ArrayAsWord16#readWord8ArrayAsWord32#readWord8ArrayAsWord64#readWord8ArrayAsWord#writeCharArray#writeWideCharArray#writeIntArray#writeWordArray#writeAddrArray#writeFloatArray#writeDoubleArray#writeStablePtrArray#writeInt8Array#writeInt16Array#writeInt32Array#writeInt64Array#writeWord8Array#writeWord16Array#writeWord32Array#writeWord64Array#writeWord8ArrayAsChar#writeWord8ArrayAsWideChar#writeWord8ArrayAsAddr#writeWord8ArrayAsFloat#writeWord8ArrayAsDouble#writeWord8ArrayAsStablePtr#writeWord8ArrayAsInt16#writeWord8ArrayAsInt32#writeWord8ArrayAsInt64#writeWord8ArrayAsInt#writeWord8ArrayAsWord16#writeWord8ArrayAsWord32#writeWord8ArrayAsWord64#writeWord8ArrayAsWord#compareByteArrays#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#atomicModifyMutVar2#atomicModifyMutVar_# 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#delay# waitRead# waitWrite#fork#forkOn#killThread#yield#myThreadId#labelThread#isCurrentThreadBound#noDuplicate# threadStatus#mkWeak#mkWeakNoFinalizer#addCFinalizerToWeak# deRefWeak# finalizeWeak#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#closureSize#getApStackVal# getCCSOf#getCurrentCCS# clearCCS#traceEvent#traceBinaryEvent#traceMarker#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#GHC.ForeignPtr ForeignPtrGHC.STSTGHC.Prim.ExtWORD64INT64getThreadAllocationCounter#resizeSmallMutableArray#atomicModifyMutVar# traceEventsortWiththemaxTupleSizeForceSpecConstrNoSpecConstrSpecConstrAnnotationItemGHC.StableNameeqStableNamehashStableName StableName GHC.Stack callStackControl.Exception.BaseNonTerminationNestedAtomically GHC.Conc.SyncThreadIdGHC.IO.ExceptionasyncExceptionFromExceptionasyncExceptionToExceptionBlockedIndefinitelyOnMVarBlockedIndefinitelyOnSTMDeadlockAllocationLimitExceededAssertionFailedSomeAsyncException UserInterruptThreadKilledHeapOverflow StackOverflowAsyncExceptionUndefinedElementIndexOutOfBoundsArrayExceptionGHC.IOMaskedUninterruptibleMaskedInterruptibleUnmaskedMaskingStateIOException GHC.ExceptionprettyCallStackprettySrcLoc ErrorCallErrorCallWithLocationGHC.Exception.TypedisplayException fromExceptiontoException ExceptionRatioZeroDenominatorDenormalDivideByZeroLossOfPrecision UnderflowOverflowArithExceptionData.MonoidgetApApData.Semigroup.InternalgetDualDualappEndoEndogetAllAllgetAnygetSumSum getProductProductgetAltAltData.OrdgetDownDown Data.ProxyProxyForeign.C.TypesCBoolForeign.PtrintPtrToPtrptrToIntPtrwordPtrToPtrptrToWordPtrWordPtrIntPtrGHC.IntuncheckedIShiftRA64#uncheckedIShiftL64#castPtrToStablePtrcastStablePtrToPtrcastPtrToFunPtrcastFunPtrToPtr castFunPtr nullFunPtrminusPtralignPtrplusPtrcastPtrnullPtrGHC.WorduncheckedShiftRL64#uncheckedShiftL64#GHC.WeakWeakrunST GHC.IO.UnsafeunsafeDupableInterleaveIOunsafeInterleaveIOunsafeDupablePerformIOunsafePerformIO GHC.Stack.CCScurrentCallStack iShiftRL# iShiftRA#iShiftL#shiftRL#shiftL#unIOgetCallStackHasCallStacksrcLocEndCol srcLocEndLinesrcLocStartColsrcLocStartLine srcLocFilesrcLocModule srcLocPackage SomeExceptionisTrue#deepseq-1.4.4.0Control.DeepSeqNFData MonadThrowthrowM$fMonadThrowWriterT$fMonadThrowRWST$fMonadThrowSelectT$fMonadThrowAccumT$fMonadThrowWriterT0$fMonadThrowWriterT1$fMonadThrowStateT$fMonadThrowStateT0$fMonadThrowRWST0$fMonadThrowRWST1$fMonadThrowReaderT$fMonadThrowMaybeT$fMonadThrowIdentityT$fMonadThrowExceptT$fMonadThrowContT$fMonadThrowSTM$fMonadThrowST$fMonadThrowIO$fMonadThrowEither$fMonadThrowMaybe MonadPrimBaseprimBaseMonadUnliftPrimwithRunInSTrunInPrimBase1runInPrimBase2 MonadPrimprim MonadUnliftIOMonadIORW runInPrimBasewithRunInIOwithRunInPrimBase primBase_prim_liftIOliftSTliftPrimBaseprimBaseToIOprimBaseToSTunSTunST_unIO_BNFtouch keepAlive# keepAliveevalevalMdeepeval deepevalM$fNFDataBNFwhenMunlessM unsafePrimunsafePrim_unsafePrimBaseunsafePrimBase_unsafePrimBaseToPrimunsafePrimBaseToSTunsafePrimBaseToIOunsafeIOToPrimunsafeSTToPrimnoDuplicatePrimunsafeDupablePerformPrimBaseunsafeInlineIOunsafeInlineSTunsafeInlinePrimBaseunsafeInterleavePrimBaseunsafeDupableInterleavePrimBaseunsafeLiftPrimBaseisSyncExceptionisAsyncExceptionimpureThrowthrowTocatchcatchAnycatchAnySynccatchAllcatchAllSynctrytryAny tryAnySync withExceptionwithAnyExceptionbracketbracketOnErrorfinallybracket_ubracket ubracket_ubracketOnErrorufinally maskPrimBase_uninterruptibleMask_uninterruptibleMaskPrimBase_maskAsyncExceptionsunmaskAsyncExceptionsmaskUninterruptiblegetMaskingState isSameMVarisEmptyMVarnewLazyMVarnewDeepMVarputLazyMVarputDeepMVartryPutLazyMVartryPutDeepMVar writeMVarswapLazyMVarswapDeepMVar clearMVarmodifyMVarMasked_modifyFetchOldMVarmodifyFetchOldMVarMaskedmodifyFetchNewMVarmodifyFetchNewMVarMasked toBaseMVarfromBaseMVar$fEqMVarmakeStableNamemakeAnyStableName$fShowStableNamesyncXorFetchNewWord64ArrayIOsyncXorFetchNewWord64AddrIOsyncXorFetchNewInt64ArrayIOsyncXorFetchNewInt64AddrIOsyncXorFetchOldWord64ArrayIOsyncXorFetchOldWord64AddrIOsyncXorFetchOldInt64ArrayIOsyncXorFetchOldInt64AddrIOsyncOrFetchNewWord64ArrayIOsyncOrFetchNewWord64AddrIOsyncOrFetchNewInt64ArrayIOsyncOrFetchNewInt64AddrIOsyncOrFetchOldWord64ArrayIOsyncOrFetchOldWord64AddrIOsyncOrFetchOldInt64ArrayIOsyncOrFetchOldInt64AddrIOsyncNandFetchNewWord64ArrayIOsyncNandFetchNewWord64AddrIOsyncNandFetchNewInt64ArrayIOsyncNandFetchNewInt64AddrIOsyncNandFetchOldWord64ArrayIOsyncNandFetchOldWord64AddrIOsyncNandFetchOldInt64ArrayIOsyncNandFetchOldInt64AddrIOsyncAndFetchNewWord64ArrayIOsyncAndFetchNewWord64AddrIOsyncAndFetchNewInt64ArrayIOsyncAndFetchNewInt64AddrIOsyncAndFetchOldWord64ArrayIOsyncAndFetchOldWord64AddrIOsyncAndFetchOldInt64ArrayIOsyncAndFetchOldInt64AddrIOsyncSubFetchNewWord64ArrayIOsyncSubFetchNewWord64AddrIOsyncSubFetchNewInt64ArrayIOsyncSubFetchNewInt64AddrIOsyncSubFetchOldWord64ArrayIOsyncSubFetchOldWord64AddrIOsyncSubFetchOldInt64ArrayIOsyncSubFetchOldInt64AddrIOsyncAddFetchNewWord64ArrayIOsyncAddFetchNewWord64AddrIOsyncAddFetchNewInt64ArrayIOsyncAddFetchNewInt64AddrIOsyncAddFetchOldWord64ArrayIOsyncAddFetchOldWord64AddrIOsyncAddFetchOldInt64ArrayIOsyncAddFetchOldInt64AddrIOsyncCasWord64ArrayIOsyncCasWord64AddrIOsyncCasInt64ArrayIOsyncCasInt64AddrIOsyncCasWord64BoolArrayIOsyncCasWord64BoolAddrIOsyncCasInt64BoolArrayIOsyncCasInt64BoolAddrIOsyncXorFetchNewWordArrayIOsyncXorFetchNewWordAddrIOsyncXorFetchNewIntArrayIOsyncXorFetchNewIntAddrIOsyncXorFetchOldWordArrayIOsyncXorFetchOldWordAddrIOsyncXorFetchOldIntArrayIOsyncXorFetchOldIntAddrIOsyncOrFetchNewWordArrayIOsyncOrFetchNewWordAddrIOsyncOrFetchNewIntArrayIOsyncOrFetchNewIntAddrIOsyncOrFetchOldWordArrayIOsyncOrFetchOldWordAddrIOsyncOrFetchOldIntArrayIOsyncOrFetchOldIntAddrIOsyncNandFetchNewWordArrayIOsyncNandFetchNewWordAddrIOsyncNandFetchNewIntArrayIOsyncNandFetchNewIntAddrIOsyncNandFetchOldWordArrayIOsyncNandFetchOldWordAddrIOsyncNandFetchOldIntArrayIOsyncNandFetchOldIntAddrIOsyncAndFetchNewWordArrayIOsyncAndFetchNewWordAddrIOsyncAndFetchNewIntArrayIOsyncAndFetchNewIntAddrIOsyncAndFetchOldWordArrayIOsyncAndFetchOldWordAddrIOsyncAndFetchOldIntArrayIOsyncAndFetchOldIntAddrIOsyncSubFetchNewWordArrayIOsyncSubFetchNewWordAddrIOsyncSubFetchNewIntArrayIOsyncSubFetchNewIntAddrIOsyncSubFetchOldWordArrayIOsyncSubFetchOldWordAddrIOsyncSubFetchOldIntArrayIOsyncSubFetchOldIntAddrIOsyncAddFetchNewWordArrayIOsyncAddFetchNewWordAddrIOsyncAddFetchNewIntArrayIOsyncAddFetchNewIntAddrIOsyncAddFetchOldWordArrayIOsyncAddFetchOldWordAddrIOsyncAddFetchOldIntArrayIOsyncAddFetchOldIntAddrIOsyncCasWordArrayIOsyncCasWordAddrIOsyncCasIntArrayIOsyncCasIntAddrIOsyncCasWordBoolArrayIOsyncCasWordBoolAddrIOsyncCasIntBoolArrayIOsyncCasIntBoolAddrIOsyncXorFetchNewWord32ArrayIOsyncXorFetchNewWord32AddrIOsyncXorFetchNewInt32ArrayIOsyncXorFetchNewInt32AddrIOsyncXorFetchOldWord32ArrayIOsyncXorFetchOldWord32AddrIOsyncXorFetchOldInt32ArrayIOsyncXorFetchOldInt32AddrIOsyncOrFetchNewWord32ArrayIOsyncOrFetchNewWord32AddrIOsyncOrFetchNewInt32ArrayIOsyncOrFetchNewInt32AddrIOsyncOrFetchOldWord32ArrayIOsyncOrFetchOldWord32AddrIOsyncOrFetchOldInt32ArrayIOsyncOrFetchOldInt32AddrIOsyncNandFetchNewWord32ArrayIOsyncNandFetchNewWord32AddrIOsyncNandFetchNewInt32ArrayIOsyncNandFetchNewInt32AddrIOsyncNandFetchOldWord32ArrayIOsyncNandFetchOldWord32AddrIOsyncNandFetchOldInt32ArrayIOsyncNandFetchOldInt32AddrIOsyncAndFetchNewWord32ArrayIOsyncAndFetchNewWord32AddrIOsyncAndFetchNewInt32ArrayIOsyncAndFetchNewInt32AddrIOsyncAndFetchOldWord32ArrayIOsyncAndFetchOldWord32AddrIOsyncAndFetchOldInt32ArrayIOsyncAndFetchOldInt32AddrIOsyncSubFetchNewWord32ArrayIOsyncSubFetchNewWord32AddrIOsyncSubFetchNewInt32ArrayIOsyncSubFetchNewInt32AddrIOsyncSubFetchOldWord32ArrayIOsyncSubFetchOldWord32AddrIOsyncSubFetchOldInt32ArrayIOsyncSubFetchOldInt32AddrIOsyncAddFetchNewWord32ArrayIOsyncAddFetchNewWord32AddrIOsyncAddFetchNewInt32ArrayIOsyncAddFetchNewInt32AddrIOsyncAddFetchOldWord32ArrayIOsyncAddFetchOldWord32AddrIOsyncAddFetchOldInt32ArrayIOsyncAddFetchOldInt32AddrIOsyncCasWord32ArrayIOsyncCasWord32AddrIOsyncCasInt32ArrayIOsyncCasInt32AddrIOsyncCasWord32BoolArrayIOsyncCasWord32BoolAddrIOsyncCasInt32BoolArrayIOsyncCasInt32BoolAddrIOsyncXorFetchNewWord16ArrayIOsyncXorFetchNewWord16AddrIOsyncXorFetchNewInt16ArrayIOsyncXorFetchNewInt16AddrIOsyncXorFetchOldWord16ArrayIOsyncXorFetchOldWord16AddrIOsyncXorFetchOldInt16ArrayIOsyncXorFetchOldInt16AddrIOsyncOrFetchNewWord16ArrayIOsyncOrFetchNewWord16AddrIOsyncOrFetchNewInt16ArrayIOsyncOrFetchNewInt16AddrIOsyncOrFetchOldWord16ArrayIOsyncOrFetchOldWord16AddrIOsyncOrFetchOldInt16ArrayIOsyncOrFetchOldInt16AddrIOsyncNandFetchNewWord16ArrayIOsyncNandFetchNewWord16AddrIOsyncNandFetchNewInt16ArrayIOsyncNandFetchNewInt16AddrIOsyncNandFetchOldWord16ArrayIOsyncNandFetchOldWord16AddrIOsyncNandFetchOldInt16ArrayIOsyncNandFetchOldInt16AddrIOsyncAndFetchNewWord16ArrayIOsyncAndFetchNewWord16AddrIOsyncAndFetchNewInt16ArrayIOsyncAndFetchNewInt16AddrIOsyncAndFetchOldWord16ArrayIOsyncAndFetchOldWord16AddrIOsyncAndFetchOldInt16ArrayIOsyncAndFetchOldInt16AddrIOsyncSubFetchNewWord16ArrayIOsyncSubFetchNewWord16AddrIOsyncSubFetchNewInt16ArrayIOsyncSubFetchNewInt16AddrIOsyncSubFetchOldWord16ArrayIOsyncSubFetchOldWord16AddrIOsyncSubFetchOldInt16ArrayIOsyncSubFetchOldInt16AddrIOsyncAddFetchNewWord16ArrayIOsyncAddFetchNewWord16AddrIOsyncAddFetchNewInt16ArrayIOsyncAddFetchNewInt16AddrIOsyncAddFetchOldWord16ArrayIOsyncAddFetchOldWord16AddrIOsyncAddFetchOldInt16ArrayIOsyncAddFetchOldInt16AddrIOsyncCasWord16ArrayIOsyncCasWord16AddrIOsyncCasInt16ArrayIOsyncCasInt16AddrIOsyncCasWord16BoolArrayIOsyncCasWord16BoolAddrIOsyncCasInt16BoolArrayIOsyncCasInt16BoolAddrIOsyncXorFetchNewWord8ArrayIOsyncXorFetchNewWord8AddrIOsyncXorFetchNewInt8ArrayIOsyncXorFetchNewInt8AddrIOsyncXorFetchOldWord8ArrayIOsyncXorFetchOldWord8AddrIOsyncXorFetchOldInt8ArrayIOsyncXorFetchOldInt8AddrIOsyncOrFetchNewWord8ArrayIOsyncOrFetchNewWord8AddrIOsyncOrFetchNewInt8ArrayIOsyncOrFetchNewInt8AddrIOsyncOrFetchOldWord8ArrayIOsyncOrFetchOldWord8AddrIOsyncOrFetchOldInt8ArrayIOsyncOrFetchOldInt8AddrIOsyncNandFetchNewWord8ArrayIOsyncNandFetchNewWord8AddrIOsyncNandFetchNewInt8ArrayIOsyncNandFetchNewInt8AddrIOsyncNandFetchOldWord8ArrayIOsyncNandFetchOldWord8AddrIOsyncNandFetchOldInt8ArrayIOsyncNandFetchOldInt8AddrIOsyncAndFetchNewWord8ArrayIOsyncAndFetchNewWord8AddrIOsyncAndFetchNewInt8ArrayIOsyncAndFetchNewInt8AddrIOsyncAndFetchOldWord8ArrayIOsyncAndFetchOldWord8AddrIOsyncAndFetchOldInt8ArrayIOsyncAndFetchOldInt8AddrIOsyncSubFetchNewWord8ArrayIOsyncSubFetchNewWord8AddrIOsyncSubFetchNewInt8ArrayIOsyncSubFetchNewInt8AddrIOsyncSubFetchOldWord8ArrayIOsyncSubFetchOldWord8AddrIOsyncSubFetchOldInt8ArrayIOsyncSubFetchOldInt8AddrIOsyncAddFetchNewWord8ArrayIOsyncAddFetchNewWord8AddrIOsyncAddFetchNewInt8ArrayIOsyncAddFetchNewInt8AddrIOsyncAddFetchOldWord8ArrayIOsyncAddFetchOldWord8AddrIOsyncAddFetchOldInt8ArrayIOsyncAddFetchOldInt8AddrIOsyncCasWord8ArrayIOsyncCasWord8AddrIOsyncCasInt8ArrayIOsyncCasInt8AddrIOsyncCasWord8BoolArrayIOsyncCasWord8BoolAddrIOsyncCasInt8BoolArrayIOsyncCasInt8BoolAddrIOsyncLockReleaseInt8AddrIOsyncLockReleaseInt8ArrayIOsyncLockTestSetInt8AddrIOsyncLockTestSetInt8ArrayIOsyncSynchronizeioCBoolToBoolBasesyncSynchronize#withMemBarrier#withMemBarrier_# 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#getSizeofMutableArray#shrinkMutableArray#resizeMutableArray#unsafeThawByteArray#mutableByteArrayContents#unsafeThawArrayArray#unInt#unWord#PrimBaseSizeOf Alignment toPrimBasefromPrimBasesizeOf# 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$fPrimCNfds$fPrimCSocklen$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$fAtomicBitsInt8spark numSparks runSparksdelaywaitRead waitWriteforkforkFinally forkOnFinallyforkOS killThreadthreadDelaytimeouttimeout_ myThreadIdlabelThreadisCurrentThreadBoundthreadStatusthreadCapabilitygetNumCapabilitiessetNumCapabilitiesthreadIdToCIntAtomunAtom"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$fNFDataAtomOffunOffCountunCount showsType byteCount byteCountTypebyteCountProxy alignment alignmentTypealignmentProxy unCountBytes#unCountBytestoByteCount countToOffcountToByteOffcountForProxyTypeOfcountForType fromByteCountfromByteCountRemoffForProxyTypeOf offForType offToCountoffToByteCount toByteOff unOffBytesunOffBytes#fromByteOfffromByteOffRemprefetchValue0prefetchValue1prefetchValue2prefetchValue3#..#$fPrimCount $fPrimOff$fEqOff $fShowOff$fOrdOff $fEnumOff$fBoundedOff$fNumOff $fIntegralOff $fRealOff$fNFDataOff $fEqCount$fShowCount $fOrdCount$fEnumCount$fBoundedCount $fNumCount$fIntegralCount$fRealCount $fNFDataCountUMArrayUArraySBMArraySBArrayBMArrayBArraySizeunSizeisSameBArraysizeOfBArrayindexBArraycloneBArray copyBArray thawBArraythawCopyBArraytoListBArrayfromListBArrayNfromListBArrayfromBaseBArraytoBaseBArray isSameBMArraygetSizeOfBMArrayreadBMArraywriteBMArraywriteLazyBMArraywriteDeepBMArray newBMArraynewLazyBMArray newRawBMArraymakeBMArray freezeBMArrayfreezeCopyBMArraycloneBMArray shrinkBMArray resizeBMArrayresizeRawBMArraymoveBMArray isSameSBArray sizeOfSBArrayindexSBArraycloneSBArrayshrinkSBMArrayresizeSBMArrayresizeRawSBMArraycopySBArraythawSBArraythawCopySBArray toListSBArrayfromListSBArrayNfromListSBArrayisSameSBMArraygetSizeOfSBMArrayreadSBMArray writeSBMArraywriteLazySBMArraywriteDeepSBMArraynewSBMArraynewLazySBMArraynewRawSBMArraymakeSBMArrayfreezeSBMArrayfreezeCopySBMArray cloneSBMArraymoveSBMArrayisSameUArrayisPinnedUArraysizeOfUArrayindexUArray copyUArray thawUArraytoListUArrayfromListUArrayNfromListUArrayfromBaseUArraytoBaseUArray isSameUMArrayisPinnedUMArraygetSizeOfUMArrayreadUMArraywriteUMArray newUMArraynewPinnedUMArraynewAlignedPinnedUMArraymakeUMArraymakePinnedUMArraymakeAlignedPinnedUMArray newRawUMArraynewRawPinnedUMArraynewRawAlignedPinnedUMArraymoveUMArray setUMArray shrinkUMArray resizeUMArray freezeUMArray uninitializedfromListMutWithmakeMutWithfoldrWithFBeqWithcompareWith appendWith concatWith $fPrimSize$fMonoidBArray$fSemigroupBArray$fOrd1BArray$fEq1BArray$fOrdBArray $fEqBArray$fNFDataBArray$fIsStringBArray$fIsListBArray$fShowBArray $fShow1BArray$fFoldableBArray$fFunctorBArray$fEqBMArray$fMonoidSBArray$fSemigroupSBArray $fOrd1SBArray$fEq1SBArray$fOrdSBArray$fEqSBArray$fNFDataSBArray$fIsStringSBArray$fIsListSBArray $fShowSBArray$fShow1SBArray$fFoldableSBArray$fFunctorSBArray$fEqSBMArray$fMonoidUArray$fSemigroupUArray$fOrdUArray $fEqUArray$fNFDataUArray$fIsStringUArray$fIsListUArray$fShowUArray$fNFDataUMArray$fEqUMArray $fShowSize$fEqSize $fOrdSize $fNumSize $fRealSize$fIntegralSize $fBoundedSize $fEnumSize setOffPtr readOffPtrreadByteOffPtrwriteOffPtrwriteByteOffPtrreadPtrwritePtrplusByteOffPtr plusOffPtrminusByteOffPtrminusOffPtrminusOffRemPtrcopyPtrToPtrcopyByteOffPtrToPtrmovePtrToPtrmoveByteOffPtrToPtrcomparePtrToPtrcompareByteOffPtrToPtr casOffPtratomicModifyOffPtratomicModifyOffPtr_atomicModifyFetchOldOffPtratomicModifyFetchNewOffPtratomicAddFetchOldOffPtratomicAddFetchNewOffPtratomicSubFetchOldOffPtratomicSubFetchNewOffPtratomicAndFetchOldOffPtratomicAndFetchNewOffPtratomicNandFetchOldOffPtratomicNandFetchNewOffPtratomicOrFetchOldOffPtratomicOrFetchNewOffPtratomicXorFetchOldOffPtratomicXorFetchNewOffPtratomicNotFetchOldOffPtratomicNotFetchNewOffPtrprefetchPtr0prefetchPtr1prefetchPtr2prefetchPtr3prefetchOffPtr0prefetchOffPtr1prefetchOffPtr2prefetchOffPtr3freeHaskellFunPtrnewStablePtrdeRefStablePtr freeStablePtr$fShowStablePtr$fNFDataStablePtrmkWeakNoFinalizermkWeakPtrNoFinalizer addCFinalizeraddCFinalizerEnvfinalizeWeakIORefRef isSameRefnewRef newDeepRef newLazyRefreadRefswapRefswapLazyRefswapDeepRefwriteRefwriteDeepRefwriteLazyRef modifyRef modifyDeepRef modifyRef_modifyFetchNewRefmodifyFetchOldRef modifyLazyRef modifyRefMmodifyDeepRefMmodifyRefM_modifyFetchOldRefMmodifyFetchNewRefMmodifyLazyRefMatomicWriteRef atomicReadRef atomicSwapRefatomicModifyRefatomicModifyRef2atomicModifyRef_atomicModifyRef2_atomicModifyFetchOldRefatomicModifyFetchOldRef2atomicModifyFetchNewRefatomicModifyFetchNewRef2atomicModifyFetchBothRefatomicModifyFetchBothRef2atomicModifyFetchRefatomicModifyFetchRef2atomicModifyFetchBothLazyRefcasRefatomicModifyFetchLazyRefatomicModifyLazyRefatomicModifyFetchOldLazyRefatomicModifyFetchNewLazyRefatomicWriteLazyReftoSTRef fromSTReftoIORef fromIORef$fEqReftransformers-0.5.6.2Control.Monad.Trans.MaybeMaybeTControl.Monad.Trans.ExceptExceptTdeepseqrnf2rnf1rwhnf<$!!>force$!!rnfNFData1liftRnfNFData2liftRnf2when Control.MonadunlessguardjoinMonadreturn>>=>>Functorfmap<$Control.Monad.Fail MonadFailfailData.TraversablemapMsequencemfilter<$!>replicateM_ replicateMfoldM_foldM zipWithM_zipWithMmapAndUnzipMforever<=<>=>filterMforM Data.Foldablemsum sequence_forM_mapM_Data.FunctorvoidapliftM5liftM4liftM3liftM2liftM=<< MonadPlusmzeromplusnoDuplicateTrueFalse GHC.MaybeNothingInt8I8#Int16I16#Int32I32#Int64I64#Word8W8#Word16W16#Word32W32#Word64W64#System.Posix.TypesCDevCInoCModeCOffCPidCSsizeCGidCNlinkCUidCCcCSpeedCTcflagCRLimCBlkSizeCBlkCntCClockId CFsBlkCnt CFsFilCntCIdCKeyCTimerCSocklenCNfdsFd LinkCountUserIDGroupID ByteCount ClockTick EpochTimeDeviceIDFileIDFileMode ProcessID FileOffsetProcessGroupIDLimitCCharCSCharCUCharCShortCUShortCIntCUIntCLongCULongCLLongCULLongCFloatCDoubleCPtrdiffCSizeCWchar CSigAtomicCClockCTime CUSeconds CSUSecondsCFileCFposCJmpBufCIntPtrCUIntPtrCIntMaxCUIntMaxleInt64ltInt64geInt64gtInt64neInt64eqInt64leInt32ltInt32geInt32gtInt32neInt32eqInt32leInt16ltInt16geInt16gtInt16neInt16eqInt16leInt8ltInt8geInt8gtInt8neInt8eqInt8bitReverse64bitReverse32bitReverse16bitReverse8 byteSwap64leWord64ltWord64geWord64gtWord64neWord64eqWord64 byteSwap32leWord32ltWord32geWord32gtWord32neWord32eqWord32 byteSwap16leWord16ltWord16geWord16gtWord16neWord16eqWord16leWord8ltWord8geWord8gtWord8neWord8eqWord8GHC.ClasseseqWordneWordeqIntneIntgtIntgeIntltIntleIntgtWordgeWordltWordleWordGHC.Conc.IOSystem.Timeout Semigroupstimes<>sconcatData.Semigroupoption mtimesDefaultdiffcycle1MingetMinMaxgetMaxArgArgMinArgMaxFirstgetFirstLastgetLast WrappedMonoid WrapMonoidunwrapMonoidOption getOptionstimesMonoidstimesIdempotentstimesIdempotentMonoidGHC.ArrArray array-0.5.4.0Data.Array.BaseGHC.Num+-