h)a      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     0.4.2# Safe-Inferred"/89:;5QW :SV<=>?JG\Z[FTUED]^_ `a')OYX984 ;7IiKjNMLkl mnopz65(H,0@ABC!"# $% &*  +~} -./123PR          bcdefgh qrs t u v w x y {|                        QW :SV<=>?JG\Z[FTUED]^_ `a')OYX984 ;7IiKjNMLkl mnopz65(H,0@ABC!"# $% &*  +~} -./123PR          bcdefgh qrs t u v w x y {|                          Safe-Inferred"/89:;Q! Safe-Inferred"/89:;QhQW :SV<=>?JG\Z[FTUED]^_ `a')OYX984 ;7IiKjNMLkl mnopz65(H,0@ABC!"# $% &*  +~} -./123PR          bcdefgh qrs t u v w x y {|                         Safe-Inferred"/89:;`\kmonad>Parsec parse errors under Void Text with an Exception instancekmonad'Parsec type specified down to Void TextkmonadHorizontal space consumptionkmonadHorizontal space lexemekmonadFull space consumptionkmonadFull space lexeme      A list of compose-sequences(c) David Janssen, 2019MITjanssen.dhj@gmail.com experimentalportable Safe-Inferred"/89:;dkmonadA collection of all supported compose-key sequences (nearly all X11 compose-key sequences). Each tuple consists of: 1. A string that, when parsed to a tap-macro, will emit the sequence. 2. The UTF-8 character that it represents 3. A descriptive-name Safe-Inferred"/89:;hkmonad.All the ways a '[Toggle a]' can be an invalid kmonadAn Off not preceded by an OnkmonadAn On not succeeded by an Offkmonad3A sequence of toggle-changes guaranteed to be validkmonadA lens into the ikmonad.A fold of all the unique elements in a gesturekmonadCreate a tapping gesturekmonad Set v` mapping, with reversing utilities(c) David Janssen, 2019MITjanssen.dhj@gmail.com experimentalportable Safe-Inferred"/89:;zkmonadThe 0, which describes a one to many (unique) mappingkmonadAll the type constraints required for something to function as a MultiMapkmonad?Create a new multimap from a foldable of (k, foldable v) pairs.kmonad5Create a new multimap from a foldable of (k, v) pairskmonad&A fold over all the (k, v) pairs in a kmonadReverse a MultiMap. Note: this is not necessarily a lossless conversion. %Description of all possible keycodes.(c) David Janssen, 2019MITjanssen.dhj@gmail.com experimentalportable Safe-Inferred"/89:;=}PkmonadThe  datatype, as an " of all the values a  can take.kmonadThe set of all existing kmonadThe set of all & that are not of the MissingXX patternkmonad*Helper function to generate easy name mapskmonadA collection of  to  mappingskmonad8A collection of useful aliases to refer to keycode names  Safe-Inferred"/89:;=~ kmonadAn  is a  on a particular kmonad Whether the  was a  or kmonadThe  mapped to this kmonadKMonad recognizes 2 different types of actions: presses and releases. Note that we do not handle repeat events at all.kmonads are mappings from  d maps from  to things.kmonad0Layers are identified by a tag that is simply a  value.kmonadPredicate on KeyEvent'skmonad Create a new  from a  and a kmonadAn +3 instance, where Press > Release, and otherwise we + on the kmonadA   instance for s that prints them out nicely.   ;The logic behind sending and receiving key events to the OS(c) David Janssen, 2019MITjanssen.dhj@gmail.com experimental5non-portable (MPTC with FD, FFI to Linux-only c-code) Safe-Inferred"/89:;kmonadA  is an action that awaits  s from the OSkmonadA  sends key actions to the OSkmonad Create a new kmonadEmit a key to the OSkmonadCreate a new KeySourcekmonad!Wait for the next key from the OSkmonadAction to acquire the keysinkkmonadAction to close the keysinkkmonad Action to write with the keysinkkmonadAction to acquire the keysourcekmonadAction to close the keysourcekmonad"Action to write with the keysource  Safe-Inferred"/89:;kmonad Create a  that represents pressing a keykmonad Create a ! that represents releaseing a keykmonad/Return whether the provided KeyEvent is a Presskmonad1Return whether the provided KeyEvent is a ReleasekmonadReturn whether the provided KeyEvent matches a particular KeycodekmonadReturth whether the provided KeyEvent matches the release of the KeycodekmonadReturn whether the provided KeyEvent matches the press of the Keycode  "Basic keyboard types(c) David Janssen, 2021MITjanssen.dhj@gmail.com experimentalportable Safe-Inferred"/89:; 1The component that provides pausing functionality(c) David Janssen, 2019MITjanssen.dhj@gmail.com experimentalportable Safe-Inferred"/89:; kmonadThe  environment.NOTE: * has no internal multithreading, i.e. its  action will never be interrupted, therefore we can simply use ) and sidestep all the STM complications.kmonadWhere we get our s fromkmonad.How many locks have been applied to the sluicekmonad,Internal buffer to store events while closedkmonad Create a new  environmentkmonad Create a new * environment, but do so in a ContT contextkmonadIncrease the block-count by 1kmonadSet the Sluice to unblocked mode, return a list of all the stored events that should be rerun, in the correct order (head was first-in, etc).(NOTE: After successfully unblocking the  will be empty, it is the caller's responsibility to insert the returned events at an appropriate location in the #$.5We do this in KMonad by writing the events into the %&s rerun buffer. (this happens in the  KMonad.App module.)kmonadTry to read from the Sluice, if we are blocked, store the event internally and return Nothing. If we are unblocked, return Just the KeyEvent.kmonadKeep trying to read from the Sluice until an event passes through Safe-Inferred"/89:;5kmonadThe  environmentkmonadHow to read 1 eventkmonadStore for reading processkmonadBuffer for rerunning eventskmonad Create a new  environmentkmonad Create a new  environment in a   environmentkmonadReturn the next event, this will return either (in order of precedence): 1. The next item to be rerun 2. A new item read from the OS 3. Pausing until either 1. or 2. triggerskmonad#Add a list of elements to be rerun.Collection of basic operations(c) David Janssen, 2019MITjanssen.dhj@gmail.com experimentalportable Safe-Inferred"/89:;'kmonadThe packet used to trigger a KeyFun, containing info about the event and how long since the Hook was registered.kmonad&Time elapsed since hook was registeredkmonad"The key event triggering this callkmonadBoolean isomorph signalling wether an event should be caught or notkmonadA = value describes how long to wait and what to do upon timeoutkmonad(Delay before timeout action is triggeredkmonadAction to perform upon timeoutkmonad&ADT signalling where to install a hookkmonad/Install the hook immediately after receiving a kmonad(Install the hook just before emitting a kmonadThe content for 1 key hookkmonadOptional timeout machinerykmonad!The function to call on the next kmonad$A newtype wrapper used to construct  actionskmonad:Type alias for `any monad that can perform MonadK actions`kmonad contains the additional bindings that get added when we are currently processing a button.kmonad7Access the keycode to which the current button is boundkmonad contains all the operations used to constitute button actions. It encapsulates all the side-effects required to get everything running.kmonadEmit a KeyEvent to the OSkmonad+Pause the current thread for n millisecondskmonad!Pause or unpause event processingkmonadRegister a callback hookkmonadRun a layer-stack manipulationkmonad"Insert an event in the input queuekmonadRun a shell-commandkmonad describes all the different layer-manipulations that KMonad supports.kmonad#Add a layer to the top of the stackkmonad%Remove the first occurence of a layerkmonadChange the base-layerkmonadCreate a KeyEvent matching pressing or releasing of the current button.kmonad(Register a simple hook without a timeoutkmonadRegister a hook with a timeoutkmonad4Perform an action after a period of time has elapsedThis is essentially just a way to perform async actions using the KMonad hook system.kmonadPerform an action immediately after the current action is finished. NOTE: there is no guarantee that another event doesn't outrace this, only that it will happen as soon as the CPU gets to it.kmonadCreate a KeyPred that matches the Press or Release of the current button.kmonadWait for an event to match a predicate and then execute an actionkmonadExecute an action on the detection of the Switch of the active button.kmonadTry to call a function on a succesful match of a predicate within a certain time period. On a timeout, perform an action.kmonadLike ;, but acquires a hold when starting, and releases when donekmonadWhere to install the hookkmonadThe timeout delay for the hookkmonad The action to perform on timeoutkmonad The action to perform on triggerkmonadThe resulting actionkmonad+The time within which this filter is activekmonad"The predicate used to find a matchkmonadThe action to call on timeoutkmonad'The action to call on a succesful matchkmonadThe resulting actionkmonad+The time within which this filter is activekmonad"The predicate used to find a matchkmonadThe action to call on timeoutkmonad'The action to call on a succesful matchkmonadThe resulting action;;Component for handling hooks(c) David Janssen, 2019MITjanssen.dhj@gmail.com experimentalportable Safe-Inferred"/89:; kmonadThe  environment that is required for keeping track of all the different targets and callbacks.kmonadWhere we get our events fromkmonadUsed to signal timeoutskmonadStore of hookskmonad Create a new 8 environment which reads events from the provided actionkmonad Create a new  environment, but as a   monad to avoid nestingkmonadConvert a hook in some UnliftIO monad into an IO version, to store it in Hookskmonad:Insert a hook, along with the current time, into the storekmonad+Cancel a hook by removing it from the storekmonadRun the function stored in a Hook on the event and the elapsed timekmonad6Run all hooks on the current event and reset the storekmonadPull 1 event from the . If that action is not caught by any callback, then return it (otherwise return Nothing). At the same time, keep reading the timer-cancellation inject point and handle any cancellation as it comes up.kmonad4Keep stepping until we succesfully get an unhandled kmonadThe  environmentkmonad-An action that returns perhaps the next eventHow buttons work(c) David Janssen, 2019MITjanssen.dhj@gmail.com experimentalportable Safe-Inferred"/89:;#kmonadA  consists of two  actions, one to take when a press is registered from the OS, and another when a release is registered.kmonadAction to take when pressedkmonadAction to take when releasedkmonad Create a " out of a press and release action NOTE: Since  is an existentially qualified , the monadic actions specified must be runnable by all implementations of 5, and therefore can only rely on functionality from !. I.e. the actions must be pure .kmonad Create a new button with only a  actionkmonad:Perform both the press and release of a button immediatelykmonadPerform the press action of a Button and register its release callback.'This performs the action stored in the 7 field and registers a callback that will trigger the  when the release is detected.kmonadA button that emits a Press of a keycode when pressed, and a release when released.kmonad.A button that emits only a Press of a keycode.kmonad0A button that emits only a Release of a keycode.kmonad)Create a new button that first presses a 0 before running an inner button, releasing the  again after the inner  is released.kmonad/Create a button that toggles a layer on and offkmonad7Create a button that switches the base-layer on a presskmonad,Create a button that adds a layer on a presskmonadCreate a button that removes the top instance of a layer on a presskmonad:Create a button that does nothing (but captures the input)kmonadCreate a button that executes a shell command on press and possibly on releasekmonadCreate a new button from 2 buttons, an inner and an outer. When the new button is pressed, first the outer is pressed, then the inner. On release, the inner is released first, and then the outer.kmonadA  that, once pressed, will surround the next button with another.Think of this as, essentially, a tappable mod. For example, an 'aroundNext KeyCtrl' would, once tapped, then make the next keypress C- whatever.kmonadA  that, once pressed, will surround the next button within some timeout with another.If some other key is not pressed within an interval another button will be triggered as a tap.kmonadA  that, once pressed, will surround the next button with another.Think of this as, essentially, a tappable mod. For example, an 'aroundNext KeyCtrl' would, once tapped, then make the next keypress C- whatever.This differs from  in that it explicitly releases the modifier immediately after the first event, where  aroundSingle waits around for the original key that was modified to be released itself.kmonadCreate a new button that performs both a press and release of the input button on just a press or releasekmonad Create a  that performs a tap of one button if it is released within an interval. If the interval is exceeded, press the other button (and release it when a release is detected).kmonad Create a  that performs a tap of 1 button if the next event is its own release, or else switches to holding some other button if the next event is a different keypress.kmonadLike 5, except that after some interval it switches anywayskmonad7Surround some future button with a before and after tapkmonadCreate a tap-hold style button that makes its decision based on the next detected release in the following manner: 1. It is the release of this button: We are tapping 2. It is of some other button that was pressed *before* this one, ignore. 3. It is of some other button that was pressed *after* this one, we hold.It does all of this while holding processing of other buttons, so time will get rolled back like a TapHold button.kmonadCreate a tap-hold style button that makes its decision based on the next detected release in the following manner: 1. It is the release of this button: We are tapping 2. It is of some other button that was pressed *before* this one, ignore. 3. It is of some other button that was pressed *after* this one, we hold.If we encounter the timeout before any other release, we switch to the specified timeout button, or to the hold button if none is specified.It does all of this while holding processing of other buttons, so time will get rolled back like a TapHold button.kmonadCreate a button just like tap-release, but also trigger a hold on presses: 1. It is the release of this button: We are tapping 2. It is the press of some other button, we hold 3. It is the release of some other button, ignore.kmonad Create a & that contains a number of delays and s. As long as the next press is registered before the timeout, the multiTap descends into its list. The moment a delay is exceeded or immediately upon reaching the last button, that button is pressed.kmonad Create a  that performs a series of taps on press. Note that the last button is only released when the tapMacro itself is released.kmonad Create a  that performs a series of taps on press, except for the last Button, which is tapped on release.kmonadSwitch to a layer for a period of time, then automatically switch backkmonadSwitch to a layer for the next button-press and switch back automaically.1NOTE: liable to change, this is essentially just  and  combined.kmonadMake a button into a sticky-key, i.e. a key that acts like it is pressed for the button after it if that button was pressed in the given timeframe.kmonadThe " to `wrap around` the inner buttonkmonad(The button to nest inside `being modded`kmonad The outer kmonad The inner kmonadThe resulting nested kmonad The outer kmonadThe resulting kmonadHow long before we tapkmonadThe  to use to surround nextkmonadThe  to tap on timeoutkmonadThe resulting buttonkmonad The outer kmonadThe resulting kmonadWhich  should trigger the tapkmonadThe  to tapkmonad The tapping $$Implementation details behind (c) David Janssen, 2019MITjanssen.dhj@gmail.com experimentalportable Safe-Inferred"/89:;?kmonadThe configuration of a 7 with some additional state to keep track of the last kmonad!The configuration for this buttonkmonadThe  to which this button is boundkmonad(State to keep track of last manipulationkmonad Initialize a ?, note that a key is always initialized in an unpressed state.kmonadTry to switch a ". This only does something if the  is different from the  field. I.e. pressing a pressed button or releasing a released button does nothing.  7Implementation of mapping key-presses to button actions(c) David Janssen, 2019MITjanssen.dhj@gmail.com experimentalportable Safe-Inferred"/89:;kmonadThe * environment containing the current keymapNOTE: Since the  will never have to deal with anything asynchronously we can simply use s here.kmonad Create a  from a  of uninitialized =s and a tag indicating which layer should start as the base.kmonad Create a  but do so in the context of a   monad to ease nesting.kmonadPrint a header message followed by an enumeration of the layer-stackkmonad%Perform operations on the layer-stackkmonad Lookup the # currently mapped to the key press.kmonadThe initial base layerkmonadThe keymap of skmonadThe  environmentkmonadThe  to performkmonadThe resulting actionkmonadThe  to lookup inkmonadThe  to lookupkmonadThe resulting action& Safe-Inferred"/89:;"$The types particular to Linux key IO(c) David Janssen, 2019MITjanssen.dhj@gmail.com experimental5non-portable (MPTC with FD, FFI to Linux-only c-code) Safe-Inferred"/89:;kmonadThe LinuxKeyEvent datatypekmonad0A smart constructor that casts from any integralkmonadConstructor for linux sync events. Whenever you write an event to linux, you need to emit a < to signal to linux that it should sync all queued updates.kmonad Translate a  to a kmonad kmonadTranslate kmonad  along with a  to s for writing.kmonad The tuple representing the eventkmonadThe LinuxKeyEvent-Using Linux's uinput interface to emit events(c) David Janssen, 2019MITjanssen.dhj@gmail.com experimentalportable Safe-Inferred"/89:;=ֵkmonad6A collection of everything that can go wrong with the kmonadCould not register devicekmonadCould not release devicekmonadCould not decode eventkmonad Invalid namekmonad3Configuration of the Uinput keyboard to instantiatekmonad%UinputSink is an MVar to a filehandlekmonadDefault Uinput configurationkmonadReturn a new uinput  with extra optionskmonad"Create and acquire a Uinput devicekmonadRelease a Uinput devicekmonad?Using a Uinput device, send a LinuxKeyEvent to the Linux kernelkmonadCreate a new UinputSinkkmonadClose a kmonadWrite a keyboard event to the sink and sync the driver state. Using an MVar ensures that we can never have 2 threads try to write at the same time.kmonad Posix handle to the file to openkmonadName to give to the keyboardkmonad Vendor IDkmonad Product IDkmonad Version IDLoad and acquire a linux dev input device(c) David Janssen, 2019MITjanssen.dhj@gmail.com experimentalportable Safe-Inferred"/89:;=kmonadA ! describes how to read and parse ;s from the binary data-stream provided by the device-file.kmonadSize of 1 input event in byteskmonad'Function to convert bytestring to eventkmonad5Perform an IOCTL operation on an open keyboard handlekmonad)Configurable components of a DeviceSourcekmonadPath to the event-filekmonad The method used to decode eventskmonad1Default configuration for parsing keyboard eventskmonadParse the log-level as either a level option or a verbose flagkmonad/Allow the execution of arbitrary shell-commandskmonadRe-emit unhandled eventskmonadTODO what does this do?kmonad$Key to use for compose-key sequenceskmonadWhere to emit the outputkmonad!How to capture the keyboard inputkmonad>Parse a flag that disables auto-releasing the release of enterkmonad(Transform a bunch of tokens of the form (Keyword, Parser)% into an optparse-applicative parserkmonad Megaparsec  -- optparse-applicative interface6How to parse arguments and config files into an AppCfg(c) David Janssen, 2019MITjanssen.dhj@gmail.com experimental5non-portable (MPTC with FD, FFI to Linux-only c-code) Safe-Inferred"/89:; kmonad"Parse a configuration file into a  recordkmonadJoin the options given from the command line with the one read from the configuration file. This does not yet throw any kind of exception, as we are simply inserting the given options into every  block that we see.The entry-point to KMonad(c) David Janssen, 2021MITjanssen.dhj@gmail.com experimental non-portable Safe-Inferred"/89:;kmonadThe first command in KMonadGet the invocation from the command-line, then do something with it.kmonadExecute the provided  Construct the log-funcParse the config-fileMaybe start KMonadkmonad4Initialize all the components of the KMonad app-loopNOTE: This is written in   over our normal RIO monad. This is just to to simplify a bunch of nesting of calls. At no point do we make use of   or other   functionality.kmonad8Trigger the button-action press currently registered to kmonad#Perform 1 step of KMonad's app loopWe forever: 1. Pull from the pull-chain until an unhandled event reaches us. 2. If that event is a ( we use our keymap to trigger an action.kmonad+Run KMonad using the provided configuration#The central app-loop of KMonad(c) David Janssen, 2019MITjanssen.dhj@gmail.com experimentalportable Safe-Inferred"/89:;()*+,-(./(.0()1()2()3()4(56(57(89+:;+:<(5=()>()?()@()A(BC(DE(8F(8G(8H(8I(JK()L()M()N()O()P()Q()R()S(TU(TV+:W(XY(8Z(8[()\(]^()_(5`+:a(bc(8d(Xe(8f(gh(ij(Bk(Dl()m(no(pq(rs()t()u+vw()x+vy+vz+v{+v|(}~(}(}(}(+v(8+v+v((((((()(+v((+v()((+v+v+v(((()((()((((((((n(n+:+:+:+:+:+:+:+:+:+:((((()()()()()()()()()()()()()()()()()()()()()()()(5(5(5(5(5(((((((((.(.(.(.(.(.(.(.(.(.(g(T(T(T(8(8(8(8(8(8(8(8(8(8(8(8(8(8(8(8(8(8(8(((((X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X(X((((((((((((((((((((n(n(n(n(n(n(n(n(n(n(n(n(n(n(n(n(n(n(n(n(n(n(n(((((((((((((((((((((((((((((((((((((((((((((((((((((((((((p(p(p(p(p(p(J(J(J(J(J(J(J(J(J(J(J(J(J(J(((((((((((((((((((((((((((((((((((((((((((((((](](](](](](](](](](](](](]((                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                %''                                           kmonad-0.4.2-inplaceKMonad.Prelude.ImportsKMonad.ParsingKMonad.Keyboard.ComposeSeqKMonad.GestureKMonad.Args.TH KMonad.UtilKMonad.Util.LayerStackKMonad.Util.MultiMapKMonad.Keyboard.KeycodeKMonad.Keyboard.TypesKMonad.Keyboard.IOKMonad.Keyboard.OpsKMonad.Model.SluiceKMonad.Model.DispatchKMonad.Model.ActionKMonad.Model.HooksKMonad.Model.ButtonKMonad.Model.BEnvKMonad.Model.KeymapKMonad.Keyboard.IO.Linux.Types#KMonad.Keyboard.IO.Linux.UinputSink%KMonad.Keyboard.IO.Linux.DeviceSourceKMonad.Args.TypesKMonad.Args.JoinerKMonad.App.TypesKMonad.Args.Parser Paths_kmonadKMonad.Args.Cmd KMonad.ArgsKMonad.App.MainkmonadKMonad.Prelude.DefinitionsKMonad.PreludeKMonad.Keyboard KMonad.AppAppDispatch KMonad.ModelAppCfgbaseGHC.Base++ghc-primGHC.PrimseqGHC.Listfilterzip otherwiseassertmap$GHC.Num fromInteger-GHC.Real fromRational GHC.Classes==>=negate>>=>>fmapreturnControl.Monad.Failfail Data.String fromString fromIntegral realToFrac toInteger toRational Control.Monadguard<>memptymappendmconcatjoin<*>pure*>GHC.EnumBoundedEnumEq GHC.FloatFloating FractionalIntegralMonad Data.DataDataFunctorNumOrdGHC.ReadReadReal RealFloatRealFracGHC.ShowShowData.Typeable.InternalTypeable MonadFailIsString Applicative Data.FoldableFoldableData.Traversable Traversable GHC.GenericsGeneric SemigroupMonoid GHC.TypesBoolStringCharDoubleFloatIntGHC.IntInt8Int16Int32Int64 ghc-bignumGHC.Num.IntegerIntegerGHC.Num.NaturalNatural GHC.MaybeMaybeOrderingRationalIOWordGHC.WordWord8Word16Word32Word64 Data.EitherEither Data.VoidVoidNonEmptyGHC.Stack.Types CallStackFalseNothingJustTrue:|LeftRightLTEQGT mtl-2.2.2Control.Monad.Reader.Class MonadReaderasklocalData.Functor.Contravariant Contravariant contramapeitherid Data.TuplefstsndliftMGHC.IO.StdHandlesstdoutstdinGHC.STSTGHC.IO.Handle.TypesHandleData.Bifunctor Bifunctorbimapasync-2.2.4-a100919d4b1bbe40fd9645896f442181f0e6286fb353d81c8ecd411b2f3db84dControl.Concurrent.AsyncAsyncCancelledAsync asyncThreadIdwaitSTM waitCatchSTMpollSTMwaitAnyCatchSTM waitAnySTMwaitEitherCatchSTM waitEitherSTMwaitEitherSTM_ waitBothSTM GHC.Conc.SyncThreadIdmapM_forM_compare<<=>maxmin/=&&||not HasCallStackGHC.Exception.Type SomeExceptionGHC.Errerror undefined MonadPlusmzeromplus Alternativeempty<|>liftA2<*<$liftAliftA3=<<whenliftM2liftM3liftM4liftM5apconst.flip$!asTypeOf+*abssignumsubtract Data.MaybemaybeisJust isNothing fromMaybe maybeToList listToMaybe catMaybesmapMaybe replicate takeWhile dropWhiletakedropspanbreakreverselookupzipWithshowfromEnumminBoundmaxBoundproperFractiontruncateroundceilingfloor/recipquotremdivmodquotRemdivModevenodd^^^gcdlcm byteSwap16 byteSwap32 byteSwap64runST floatRadix floatDigits floatRange decodeFloat encodeFloatexponent significand scaleFloatisNaN isInfiniteisDenormalizedisNegativeZeroisIEEEatan2piexplogsqrt**logBasesincostanasinacosatansinhcoshtanhasinhacoshatanhTVarleftsrightspartitionEithersisLeftisRightfromLeft fromRight Text.Read readMaybe Data.BoolboolForeign.StorableStorableData.OrdDowngetDown comparingData.Type.Equality:~:Refl Data.ProxyProxyfoldfoldMapfoldrfoldl'toListnulllengthelemsumproduct traverse_for_ sequenceA_ sequence_asummsumconcat concatMapandoranyallnotElemcurryuncurry Data.OldListwordsunwordsGHC.MVarMVar Exception toException fromExceptiondisplayExceptionGHC.IO.Exception IOExceptionGHC.IOFilePath GHC.IORefIORef GHC.IO.DeviceSeekMode AbsoluteSeek RelativeSeek SeekFromEnd BufferMode NoBuffering LineBufferingBlockBufferingExitCode ExitSuccess ExitFailureSomeAsyncExceptionasyncExceptionToExceptionasyncExceptionFromException GHC.IO.IOModeIOModeReadMode WriteMode AppendMode ReadWriteMode Data.Functor<$><&>$>void Data.Functionfixon&STMorElsenewTVarreadTVar writeTVarstderrData.Functor.IdentityIdentity runIdentityData.Functor.ConstConstgetConstControl.CategoryCategory>>> Control.ArrowArrow***&&&Control.Applicativeoptionaltraverse sequenceAmapMsequenceforforMfilterM>=><=<forever mapAndUnzipMzipWithM zipWithM_foldMfoldM_ replicateM replicateM_unless<$!>mfilterControl.Monad.IO.ClassMonadIOliftIOfirstsecondData.Bifoldable Bifoldablebifold bifoldMapbifoldrbifoldlbifoldr'bifoldr1bifoldrMbifoldl'bifoldl1bifoldlM bitraverse_bifor_ bisequence_biasumbiListbinullbilengthbielembiconcat bimaximum biminimumbisum biproduct biconcatMapbiandbiorbianybiall bimaximumBy biminimumBy binotElembifindData.Bitraversable Bitraversable bitraverse bisequencebifor bimapAccumL bimapAccumRControl.Concurrent.QSemNQSemNControl.Concurrent.QSemQSemControl.Concurrent.ChanChangfoldlgunfoldtoConstr dataTypeOf dataCast1 dataCast2gmapTgmapQlgmapQrgmapQgmapQigmapMgmapMpgmapMoabsurd>$bytestring-0.11.5.2 Data.ByteString.Builder.InternalBuilderData.ByteString.Internal.Type ByteStringData.ByteString.Short.InternalShortByteString fromShorttoShort text-2.0.2Data.Text.InternalTextcontainers-0.6.7Data.Set.InternalSetData.Sequence.InternalSeqData.Map.InternalMapData.IntSet.InternalIntSetData.IntMap.InternalIntMapdeepseq-1.4.8.0Control.DeepSeqNFDatarnfdeepseq$!!forceexceptions-0.10.5Control.Monad.CatchHandler MonadThrowthrowMtransformers-0.5.6.2Control.Monad.Trans.Classlifthashable-1.4.3.0-51cdb3a3d0578f7b165b5aa8505c4a30fac69cb3dcec2798e7ec7f1ea00df1bfData.Hashable.ClassHashableindexed-traversable-0.1.2.1-cd616001ed53558058d421fa1cb34f4600670cf9b6f319d3e73eda90a0f17dbc WithIndexTraversableWithIndex itraverseFoldableWithIndexifoldMap ifoldMap'ifoldrifoldlifoldr'ifoldl'FunctorWithIndeximapData.Traversable.WithIndexiforimapMiforM imapAccumR imapAccumLData.Foldable.WithIndexianyiallinonenone itraverse_ifor_imapM_iforM_ iconcatMapifindifoldrMifoldlMitoListprofunctors-5.6.2-9f24dfa153842ed6fc73b509bd5967795826b90be6d0d49708e94cc33e12f5ecData.Profunctor.Unsafe ProfunctordimaplmaprmapData.Profunctor.ChoiceChoiceleft'right'reflection-2.1.7-c3a4816a0e1c9e2e66889cba5b1275b13e1d9c615ccba81fb7addf5572a177a1Data.ReflectionfoldBy foldMapBy traverseBy sequenceBysemigroupoids-6.0.0.1-10f8b769a98d05faf3e878d4e5b3367281d348744a95a0167a20408764c4b06b Data.Semigroup.Traversable.Class Traversable1 traverse1lens-5.2.3-6cafe23adf651280df68d7ed6ed4076d254ad082ddbd38f1e5756a9c8e3c0d85Control.Lens.Internal.Iso Reversing reversingControl.Lens.Internal.LevelLevelControl.Lens.Internal.IndexedIndexed runIndexed Indexableindexed Conjoineddistrib conjoinedindexing indexing64 withIndexasIndexControl.Lens.Internal.Fold RightmostLeftmost Sequenced TraversedControl.Lens.Internal.ContextContext'ContextControl.Lens.Internal.BazaarBazaar1'Bazaar1 runBazaar1Bazaar'Bazaar runBazaarControl.Lens.Internal.MagmaMagmaControl.Lens.Internal.Review ReviewableretaggedControl.Lens.Internal.SetterSettableControl.Lens.TypeOver'OverIndexedLensLike'IndexedLensLike LensLike'LensLikeOptical'OpticalOptic'OpticSimpleIndexPreservingFold1 IndexedFold1Fold1IndexPreservingFold IndexedFoldFoldIndexPreservingGetter IndexedGetterGetterAs Equality'EqualityPrism'PrismAReviewReviewIso'IsoIndexPreservingSetter'IndexPreservingSetterIndexedSetter' IndexedSetterSetter'SetterIndexPreservingTraversal1'IndexPreservingTraversal1IndexPreservingTraversal'IndexPreservingTraversalIndexedTraversal1'IndexedTraversal1IndexedTraversal'IndexedTraversal Traversal1' Traversal1 Traversal' TraversalIndexPreservingLens'IndexPreservingLens IndexedLens' IndexedLensLens'LensControl.Lens.SetterSetting'SettingAnIndexedSetter'AnIndexedSetterASetter'ASettermappedlifted contramappedargumentsettingsets cloneSettercloneIndexPreservingSettercloneIndexedSetteroversetset'%~.~?~<.~~<>=scribepassingipassing censoring icensoringlocallyilocallyioverisetisets%@~.@~%@= imodifying.@=assignAmapOfimapOfControl.Lens.LensAnIndexedLens' AnIndexedLensALens'ALenslenswithLensiplensilens&~%%~%%=??insidechoosingchosen alongsidelocus cloneLenscloneIndexPreservingLenscloneIndexedLens<%~<+~<-~<*~~<%=<+=<-=<*==<<~<<>~<<>=overA<%@~<<%@~%%@~%%@=<%@=<<%@=^#storing#~#%~#%%~#=#%=<#%~<#%=#%%=<#~<#=devoidunitedhead1last1fusingControl.Lens.TupleField19_19Field18_18Field17_17Field16_16Field15_15Field14_14Field13_13Field12_12Field11_11Field10_10Field9_9Field8_8Field7_7Field6_6Field5_5Field4_4Field3_3Field2_2Field1_1_1'_2'_3'_4'_5'_6'_7'_8'_9'_10'_11'_12'_13'_14'_15'_16'_17'_18'_19'Control.Lens.Getter AccessingIndexedGettingGettingtoitolikeilikeviewviews^.useuses listening ilistening listenings ilisteningsiviewiviewsiuseiuses^@.gettingControl.Lens.Reviewuntounrereview#reviewsreusereuses reviewingControl.Lens.PrismSuffixedsuffixedPrefixedprefixedAPrism'APrism withPrism clonePrismprismprism'outsidewithoutasidebelowisn'tmatching matching'_Left_Right_Just_Nothing_Voidonlynearly_ShowControl.Lens.Foldfoldingifoldingfoldring ifoldringfoldedfolded64repeated replicatedcycledunfoldediteratedfiltered filteredBy takingWhile droppingWhilewordedlined foldMapOffoldOffoldrOffoldlOftoListOf toNonEmptyOfaltOf^..andOforOfanyOfallOfnoneOf productOfsumOf traverseOf_forOf_ sequenceAOf_ traverse1Of_for1Of_ sequence1Of_mapMOf_forMOf_ sequenceOf_asumOfmsumOfelemOf notElemOf concatMapOfconcatOflengthOf^?^?!firstOffirst1OflastOflast1OfnullOf notNullOf maximumOf maximum1Of minimumOf minimum1Of maximumByOf minimumByOffindOffindMOflookupOffoldr1Offoldl1OffoldrOf'foldlOf' foldr1Of' foldl1Of'foldrMOffoldlMOfhashasn'tpreiprepreviewipreviewpreviews ipreviewspreuseipreusepreusesipreuses backwards ifoldMapOfifoldrOfifoldlOfianyOfiallOfinoneOf itraverseOf_iforOf_imapMOf_iforMOf_ iconcatMapOfifindOfifindMOf ifoldrOf' ifoldlOf' ifoldrMOf ifoldlMOf itoListOf^@..^@?^@?! elemIndexOf elemIndicesOf findIndexOf findIndicesOf ifiltered itakingWhileidroppingWhilefoldByOf foldMapByOfControl.Lens.Traversal TraverseMax traverseMax TraverseMin traverseMin Traversing1' Traversing' Traversing1 TraversingAnIndexedTraversal1'AnIndexedTraversal'AnIndexedTraversal1AnIndexedTraversal ATraversal1' ATraversal1 ATraversal' ATraversal traversal traverseOfforOf sequenceAOfmapMOfforMOf sequenceOf transposeOf mapAccumROf mapAccumLOfscanr1Ofscanl1OflociilocipartsOfipartsOfpartsOf' ipartsOf' unsafePartsOfiunsafePartsOfunsafePartsOf'iunsafePartsOf'singularunsafeSingularholesOfholes1Ofbothboth1besidetakingdroppingcloneTraversalcloneIndexPreservingTraversalcloneIndexedTraversalcloneTraversal1cloneIndexPreservingTraversal1cloneIndexedTraversal1 itraverseOfiforOfimapMOfiforMOf imapAccumROf imapAccumLOf traversed traversed1 traversed64ignored elementOfelement elementsOfelementsfailover ifailoverfailingdeepOf confusing traverseByOf sequenceByOfControl.Lens.LevellevelsilevelsControl.Lens.Reified ReifiedPrism' ReifiedPrismrunPrism ReifiedIso' ReifiedIsorunIsoReifiedIndexedSetter'ReifiedIndexedSetterrunIndexedSetterReifiedSetter' ReifiedSetter runSetterReifiedIndexedFoldrunIndexedFold ReifiedFoldrunFoldReifiedIndexedGetterrunIndexedGetter ReifiedGetter runGetterReifiedTraversal'ReifiedTraversal runTraversalReifiedIndexedTraversal'ReifiedIndexedTraversalrunIndexedTraversalReifiedIndexedLens'ReifiedIndexedLensrunIndexedLens ReifiedLens' ReifiedLensrunLensControl.Lens.Indexed<..> selfIndex reindexed<.>icomposeindicesindeximappedifolded itraversed ifoldMapBy ifoldMapByOf itraverseBy itraverseByOfControl.Lens.Equality AnEquality' AnEquality IdenticalrunEqsubstEqmapEqfromEqsimplysimple cloneEqualityequality equality' overEquality underEquality fromLeibniz fromLeibniz' withEqualityControl.Lens.IsoAnIso'AnIsoListReversedSwappedLazyStrictisofromwithIsocloneIsoauaufxplatxplatfunderenummappingnonnon'anoncurried uncurriedflippedswappedstrictlazyreversed involutedmagmaimagma contramapping dimappinglmappingrmapping bimappingfirsting secondingcoercedControl.Lens.EmptyAsEmpty_EmptyEmptyControl.Lens.ConsSnoc_SnocCons_Cons:>:<<|consuncons_head_tail_init_last|>snocunsnocControl.Lens.Wrapped Rewrapping RewrappedWrapped Unwrapped _Wrapped' _GWrapped' _Unwrapped'_Wrapped _Unwrappedop _Wrapping' _Unwrapping' _Wrapping _UnwrappingalaalafControl.Lens.ZoomMagnifymagnifyZoomzoom MagnifiedZoomedControl.Lens.PlatedGPlated1GPlatedPlatedplate...deepchildrenrewrite rewriteOf rewriteOn rewriteOnOfrewriteM rewriteMOf rewriteMOn rewriteMOnOfuniverse universeOf universeOn universeOnOfcosmoscosmosOfcosmosOn cosmosOnOf transform transformOn transformOf transformOnOf transformM transformMOn transformMOftransformMOnOfcontexts contextsOf contextsOn contextsOnOfholesholesOn holesOnOfparaOfpara composOpFoldpartsgplategplate1Control.Lens.EachEacheachControl.Lens.AtAtatIxedixIxValueContainscontainsIndex icontainsiixixAtsansiatControl.Lens.Internal.PrismTH makePrismsmakeClassyPrismsControl.Lens.Internal.FieldTH ClassyNamerDefNameTopName MethodName FieldNamer LensRulesControl.Lens.TH simpleLensesgenerateSignaturesgenerateUpdateableOpticsgenerateLazyPatternsgenerateRecordSyntax createClass lensField lensClass lensRulesunderscoreNoPrefixNamer lensRulesForlookingupNamer mappingNamer classyRules classyRules_ makeLenses makeClassy makeClassy_ makeLensesFor makeClassyFormakeLensesWith declareLensesdeclareLensesFor declareClassydeclareClassyFor declarePrismsdeclareWrapped declareFieldsdeclareLensesWith makeWrappedunderscoreFieldsunderscoreNamercamelCaseFieldscamelCaseNamerclassUnderscoreNoPrefixFieldsclassUnderscoreNoPrefixNamerabbreviatedFieldsabbreviatedNamer makeFieldsmakeFieldsNoPrefixdefaultFieldRulesControl.Monad.Trans.ReaderReadervector-0.13.0.0-396be3184123d3d2c79e724248891b34b6048b667462fc3b4a726738de74726f Data.VectorVectorunordered-containers-0.2.19.1-b8607da5b052df13a484a31a7160b9989e7e299eacb5f792c77ec086ec6c560fData.HashSet.InternalHashSetData.HashMap.InternalHashMapData.Vector.Unboxed.BaseUnboxmegaparsec-9.5.0-4382cc5a8aa3d0b27e8548a7f445a63247e37f4341e88c836fd32297676763ffText.Megaparsec.Pos SourcePos sourceName sourceLine sourceColumnInvalidPosExceptionPosmkPosunPospos1defaultTabWidth initialPossourcePosPrettyText.Megaparsec.StatePosState pstateInput pstateOffsetpstateSourcePospstateTabWidthpstateLinePrefixState stateInput stateOffset statePosStatestateParseErrorsText.Megaparsec.StreamTraversableStream reachOffsetreachOffsetNoLine VisualStream showTokens tokensLength NoShareInputunNoShareInput ShareInput unShareInputStreamTokenTokens tokenToChunk tokensToChunk chunkToTokens chunkLength chunkEmptytake1_takeN_ takeWhile_Text.Megaparsec.ErrorShowErrorComponentshowErrorComponenterrorComponentLenParseErrorBundle bundleErrorsbundlePosState TrivialError FancyError ErrorFancy ErrorFailErrorIndentation ErrorCustom ErrorItemLabel EndOfInput mapParseError errorOffsetsetErrorOffsetattachSourcePoserrorBundlePrettyparseErrorPrettyparseErrorTextPretty showErrorItemText.Megaparsec.Class MonadParsec parseErrorlabelhiddentry lookAhead notFollowedBy withRecovery observingeoftokentokens takeWhileP takeWhile1PtakePgetParserStateupdateParserStatemkParsecText.Megaparsec.InternalParsecTText.MegaparsecParsecparse parseMaybe parseTest runParser runParser' runParserT runParserT'failure fancyFailure unexpected customFailureregionregisterParseErrorregisterFailureregisterFancyFailuresinglesatisfy anySingle anySingleButoneOfchunkmatchtakeRestatEndgetInputsetInput getSourcePos getOffset setOffsetsetParserStateparser-combinators-1.3.0-2aa55a29adc86d74b83eaefa8d0c769bc097113e8cb143e60352088d5b9426c5Control.Monad.CombinatorssomemanyControl.Applicative.CombinatorschoicecountbetweenoptionskipManysepBysepBy1endByendBy1manyTillcount'eitherP manyTill_someTill someTill_sepEndBy sepEndBy1skipSome skipCount skipManyTill skipSomeTillReaderTasksControl.Monad.Trans.ContContTrunContTContcontrunContmapContwithContmapContT withContT runReaderT runReaderControl.Monad.Cont.Class MonadContcallCC MonadTransprimitive-0.8.0.0-e503bef822b7266b99411b1d512f92c0fc035deedf290383f529d606b0c5cd0fControl.Monad.Primitive PrimMonad PrimState primitiveunliftio-core-0.2.1.0-a2983af872ff8e304fe13086819f85a5d28f0781e5ccb47a8fdaed117d17865fControl.Monad.IO.Unlift MonadUnliftIOresourcet-1.3.0-d2cde1cce81f76cae0d2ba144496641cef7930079915a257737d26878086ce3fData.Acquire.InternalAcquire ReleaseType ReleaseEarly ReleaseNormalReleaseExceptionWithReleaseException mkAcquire mkAcquireTypewith Data.AcquireallocateAcquire withAcquireData.Text.Encoding.ErrorUnicodeException DecodeError EncodeError lenientDecodepackData.Text.ShowunpackData.Text.EncodingdecodeUtf8With decodeUtf8'encodeUtf8Builder encodeUtf8 Data.Textlinesunlinesunliftio-0.2.25.0-603d51cd5a5a56fc8d175440bfb65f4c06df8126e8f0c5a3c76ef528c0ba1c12 UnliftIO.IOwithBinaryFileUnliftIO.Concurrent myThreadId threadDelaythreadWaitReadthreadWaitWriteisCurrentThreadBoundrio-0.1.22.0-4b12ab433f5825f3fe003b5d3480d00acff52c8625d186f83b67481cbfaa55a0RIO.Prelude.DisplayDisplaydisplay textDisplay Utf8BuildergetUtf8Builder displayShowdisplayBytesUtf8utf8BuilderToTextutf8BuilderToLazyTextwriteFileUtf8BuilderRIO.Prelude.Exit exitFailure exitSuccessexitWithRIO.Prelude.ExtramapLeft fromFirst mapMaybeA forMaybeA mapMaybeM forMaybeMfoldMapMnubOrdwhenMunlessMasIORIO.Prelude.RenamesLText LByteStringGVectorSVectorUVectorsappend toStrictBytesfromStrictBytes yieldThreadRIO.Prelude.TexttshowdecodeUtf8LenientRIO.Prelude.Logger HasLogSource getLogSource HasLogLevel getLogLevelGLogFunc HasGLogFuncGMsg gLogFuncL LogOptionsLogFunc HasLogFunclogFuncL LogSourceLogLevel LevelDebug LevelInfo LevelWarn LevelError LevelOther mkLogFunc logGenericlogDebuglogInfologWarnlogErrorlogOther logDebugSlogInfoSlogWarnS logErrorS logOtherS logSticky logStickyDonelogOptionsMemorylogOptionsHandle newLogFunc withLogFuncsetLogMinLevelsetLogMinLevelIOsetLogVerboseFormatsetLogVerboseFormatIOsetLogTerminal setLogUseTimesetLogUseColorsetLogLevelColorssetLogSecondaryColorsetLogAccentColors setLogUseLoc setLogFormatdisplayCallStacklogFuncUseColorLlogFuncLogLevelColorsLlogFuncSecondaryColorLlogFuncAccentColorsL noLoggingcontramapMaybeGLogFunccontramapGLogFunc mkGLogFuncgloggLogFuncClassicRIO.Prelude.IO withLazyFilewithLazyFileUtf8 writeFileUtf8 hPutBuilderreadFileBinarywriteFileBinary readFileUtf8 RIO.DequeBDequeSDequeUDequeDequeasUDequeasSDequeasBDequenewDeque getDequeSize popFrontDeque popBackDequepushFrontDeque pushBackDeque foldlDeque foldrDeque dequeToList dequeToVector freezeDequeRIO.Prelude.URefIOURefURefnewURefreadURef writeURef modifyURefRIO.Prelude.RIO HasWriteRef writeRefL HasStateRef stateRefLSomeRefRIOunRIOrunRIOliftRIOmapRIO readSomeRef writeSomeRef modifySomeRef newSomeRefnewUnboxedSomeRefRIO.Prelude.Simple SimpleApp mkSimpleApp runSimpleAppRIO.Prelude.TracetracetraceIdtraceIOtraceM traceEvent traceEventIO traceMarker traceMarkerIO traceStack traceShow traceShowId traceShowIO traceShowMtraceShowEventtraceShowEventIOtraceShowMarkertraceShowMarkerIOtraceShowStack traceDisplaytraceDisplayIdtraceDisplayIO traceDisplayMtraceDisplayEventtraceDisplayEventIOtraceDisplayMarkertraceDisplayMarkerIOtraceDisplayStackUnliftIOunliftIOUnliftIO.Internals.Async ConcurrentlyrunConcurrentlysafe-exceptions-0.1.7.4-1907423881d1bca1088325c507fa9aaab9a32cfe75f8a223a97a67e415a52a06Control.Exception.SafeAsyncExceptionWrapperSyncExceptionWrapperUnliftIO.ExceptionStringException stm-2.5.1.0Control.Concurrent.STM.TBQueueTBQueueControl.Concurrent.STM.TChanTChanControl.Concurrent.STM.TMVarTMVarControl.Concurrent.STM.TQueueTQueue ConcExceptionEmptyWithNoAlternativeConcUnliftIO.MemoizeMemoized withRunInIOasync asyncBoundasyncOnasyncWithUnmaskasyncOnWithUnmask withAsyncwithAsyncBound withAsyncOnwithAsyncWithUnmaskwithAsyncOnWithUnmaskwait waitCatchpollcanceluninterruptibleCancel cancelWith waitAnyCatchwaitAnyCatchCancelwaitAny waitAnyCancelwaitEitherCatchwaitEitherCatchCancel waitEither waitEither_waitEitherCancelwaitBothlinklink2racerace_ concurrently concurrently_mapConcurrentlyforConcurrentlymapConcurrently_forConcurrently_replicateConcurrentlyreplicateConcurrently_ UnliftIO.STM atomicallybracketopenFilethrowToUnliftIO.IORefatomicModifyIORefhSeekhFlushmaskthrowIO newTChanIOnewBroadcastTChanIO newTQueueIO newTBQueueIO newTMVarIOcatchhClose hWaitForInput UnliftIO.MVar newEmptyMVarnewMVartakeMVarreadMVarputMVar tryTakeMVar tryPutMVar tryReadMVar isEmptyMVarcatchAny onExceptionmask_uninterruptibleMask_uninterruptibleMaskfinallyevaluatenewIORef readIORef writeIORefatomicModifyIORef' mkWeakIORef modifyIORef modifyIORef'atomicWriteIORefgetMonotonicTime newTVarIO readTVarIOwithMVar modifyMVar_ catchJusthandle handleJusttryJustbracket_bracketOnErrorcatchesswapMVarwithMVarMasked modifyMVarmodifyMVarMasked_modifyMVarMasked mkWeakMVar registerDelaywithFile hFileSize hSetFileSizehIsEOF hSetBufferinghTellhIsOpen hIsClosed hIsReadable hIsWritable hGetBuffering hIsSeekablehSetEchohGetEchohIsTerminalDevicehReadyUnliftIO.QSemNnewQSemN waitQSemN signalQSemN UnliftIO.QSemnewQSemwaitQSem signalQSem UnliftIO.ChannewChan writeChanreadChandupChangetChanContentswriteList2ChanUnliftIO.Timeouttimeout throwString impureThrowcatchIO catchDeep catchAnyDeephandleIO handleAny handleDeep handleAnyDeeptryIOtryAnytryDeep tryAnyDeep withExceptionbracketOnError_toSyncExceptiontoAsyncExceptionisSyncExceptionisAsyncException catchesDeep evaluateDeep newTBQueue writeTBQueue readTBQueuetryReadTBQueue flushTBQueue peekTBQueuetryPeekTBQueue unGetTBQueue lengthTBQueueisEmptyTBQueue isFullTBQueuenewTChannewBroadcastTChan writeTChan readTChan tryReadTChan peekTChan tryPeekTChandupTChan unGetTChan isEmptyTChan cloneTChannewTMVar newEmptyTMVarnewEmptyTMVarIO takeTMVar tryTakeTMVarputTMVar tryPutTMVar readTMVar tryReadTMVar swapTMVar writeTMVar isEmptyTMVar mkWeakTMVar newTQueue writeTQueue readTQueue tryReadTQueue peekTQueue tryPeekTQueue unGetTQueue isEmptyTQueueControl.Concurrent.STM.TVar modifyTVar modifyTVar' stateTVarswapTVar mkWeakTVarcatchSyncOrAsynchandleSyncOrAsynctrySyncOrAsyncpureTry pureTryDeepfromExceptionUnwrapstringException fromEither fromEitherIO fromEitherM mapExceptionMconcrunConcpooledMapConcurrentlyNpooledMapConcurrentlypooledForConcurrentlyNpooledForConcurrentlypooledMapConcurrentlyN_pooledMapConcurrently_pooledForConcurrently_pooledForConcurrentlyN_pooledReplicateConcurrentlyNpooledReplicateConcurrentlypooledReplicateConcurrentlyN_pooledReplicateConcurrently_ runMemoized memoizeRef memoizeMVarwithQSem withQSemNretrySTMcheckSTMUnliftIO.TemporarywithSystemTempFilewithSystemTempDirectory withTempFilewithTempDirectory askUnliftIO askRunInIO withUnliftIOtoIOwrappedWithRunInIOliftIOOp ParseError _parseErrorParserTParserhschlexsclex$fExceptionParseError$fShowParseError$fEqParseError ssComposedGestureReadErrorGestureParseErrorGestureValidateErrorGest GestureError OffWithoutOn OnWithoutOffGesture_gestureToggleOnOfftagtagstaparoundfromList prsGesturereservedtag_around_closeTagopenTagtap_subggest$fMonoidGesture$fSemigroupGesture$fExceptionGestureReadError$fShowGestureReadError$fEqGestureReadError$fEqGestureError$fShowGestureError $fEqGesture $fShowGesture$fFunctorGesture $fEqToggle $fShowToggle$fFunctorTogglegitHash MillisecondsunMStDiffonErrusing logRethrow withLaunch withLaunch_launchlaunch_$fEqMilliseconds$fOrdMilliseconds$fNumMilliseconds$fRealMilliseconds$fEnumMilliseconds$fIntegralMilliseconds$fShowMilliseconds$fReadMilliseconds$fGenericMilliseconds$fDisplayMillisecondsLayerStackErrorLayerDoesNotExistLayerNotOnStack$fShowLayerStackError LayerStackLayerAsLayerStackError_LayerStackError_LayerDoesNotExist_LayerNotOnStackmkLayer$fExceptionLayerStackError#$fAsLayerStackErrorLayerStackErrorl$fShowLayerStack$fEqLayerStack$fFunctorLayerStack $fShowLayer $fEqLayer $fOrdLayer$fFunctorLayer$fFoldableLayer$fTraversableLayeritemsmapsstack mkLayerStackatKeyinLayer pushLayerpopLayerMultiMap$fShowMultiMap mkMultiMapfromSingletonsitemed $fAtMultiMap$fIxedMultiMap$fMonoidMultiMap$fSemigroupMultiMapKeycode KeyReservedKeyEscKey1Key2Key3Key4Key5Key6Key7Key8Key9Key0KeyMinusKeyEqual KeyBackspaceKeyTabKeyQKeyWKeyEKeyRKeyTKeyYKeyUKeyIKeyOKeyP KeyLeftBrace KeyRightBraceKeyEnter KeyLeftCtrlKeyAKeySKeyDKeyFKeyGKeyHKeyJKeyKKeyL KeySemicolon KeyApostropheKeyGrave KeyLeftShift KeyBackslashKeyZKeyXKeyCKeyVKeyBKeyNKeyMKeyCommaKeyDotKeySlash KeyRightShift KeyKpAsterisk KeyLeftAltKeySpace KeyCapsLockKeyF1KeyF2KeyF3KeyF4KeyF5KeyF6KeyF7KeyF8KeyF9KeyF10 KeyNumLock KeyScrollLockKeyKp7KeyKp8KeyKp9 KeyKpMinusKeyKp4KeyKp5KeyKp6 KeyKpPlusKeyKp1KeyKp2KeyKp3KeyKp0KeyKpDot Missing84KeyZenkakuHankakuKey102ndKeyF11KeyF12KeyRo KeyKatakana KeyHiragana KeyHenkanKeyKatakanaHiragana KeyMuhenkan KeyKpjpcomma KeyKpEnter KeyRightCtrl KeyKpSlashKeySysRq KeyRightAlt KeyLinefeedKeyHomeKeyUp KeyPageUpKeyLeftKeyRightKeyEndKeyDown KeyPageDown KeyInsert KeyDeleteKeyMacroKeyMute KeyVolumeDown KeyVolumeUpKeyPower KeyKpEqualKeyKpPlusMinusKeyPauseKeyScale KeyKpComma KeyHangeulKeyHanjaKeyYen KeyLeftMeta KeyRightMeta KeyComposeKeyStopKeyAgainKeyPropsKeyUndoKeyFrontKeyCopyKeyOpenKeyPasteKeyFindKeyCutKeyHelpKeyMenuKeyCalcKeySetupKeySleep KeyWakeUpKeyFile KeySendFile KeyDeleteFileKeyXferKeyProg1KeyProg2KeyWwwKeyMsDos KeyCoffee KeyDirectionKeyCycleWindowsKeyMail KeyBookmarks KeyComputerKeyBack KeyForward KeyCloseCd KeyEjectCdKeyEjectCloseCd KeyNextSong KeyPlayPauseKeyPreviousSong KeyStopCd KeyRecord KeyRewindKeyPhoneKeyIso KeyConfig KeyHomepage KeyRefreshKeyExitKeyMoveKeyEdit KeyScrollUp KeyScrollDownKeyKpLeftParenKeyKpRightParenKeyNewKeyRedoKeyF13KeyF14KeyF15KeyF16KeyF17KeyF18KeyF19KeyF20KeyF21KeyF22KeyF23KeyF24 Missing195 Missing196 Missing197 Missing198 Missing199 KeyPlayCd KeyPauseCdKeyProg3KeyProg4 KeyDashboard KeySuspendKeyCloseKeyPlayKeyFastForward KeyBassBoostKeyPrintKeyHp KeyCameraKeySound KeyQuestionKeyEmailKeyChat KeySearch KeyConnect KeyFinanceKeySportKeyShop KeyAlterase KeyCancelKeyBrightnessDownKeyBrightnessUpKeyMediaKeySwitchVideoModeKeyKbdIllumToggleKeyKbdIllumDown KeyKbdIllumUpKeySendKeyReplyKeyForwardMailKeySave KeyDocuments KeyBattery KeyBluetoothKeyWlanKeyUwb KeyUnknown KeyVideoNext KeyVideoPrevKeyBrightnessCycleKeyBrightnessZero KeyDisplayOffKeyWimax Missing247 Missing248 Missing249 Missing250 Missing251 Missing252 Missing253 Missing254 Missing255keyNames$fDisplayKeycode $fEqKeycode $fShowKeycode$fBoundedKeycode $fEnumKeycode $fOrdKeycode$fGenericKeycode$fHashableKeycodeKeyEventSwitchPressRelease $fEqKeyEvent$fShowKeyEvent$fGenericKeyEvent$fHashableKeyEvent $fEqSwitch $fOrdSwitch $fShowSwitch $fEnumSwitch$fGenericSwitch$fHashableSwitchLMapLayerTagKeyPred HasKeyEventkeyEventkeycodeswitch mkKeyEvent $fOrdKeyEvent$fDisplayKeyEvent$fHasKeyEventKeyEvent KeySourceKeySink mkKeySinkemitKey mkKeySourceawaitKeymkPress mkReleaseisPress isRelease isKeycode isReleaseOf isPressOfSluicemkSluiceblockunblockpull mkDispatchrerunTrigger_elapsed_eventCatchNoCatch $fMonoidCatch$fSemigroupCatch $fShowCatch $fEqCatchTimeout_delay_action HookLocation InputHook OutputHook HasTriggertriggerelapsedevent$fHasTriggerTrigger$fEqHookLocation$fShowHookLocationHook _hTimeout_keyH HasTimeoutactiondelay$fHasTimeoutTimeoutmAction runActionAnyKMonadK myBindingMonadKIOemitpauseholdregisterlayerOpinjectshellCmdLayerOp PushLayerPopLayer SetBaseLayerHasHookhookhTimeoutkeyHmyhookFtHookFafterwhenDonematchMyawaitawaitMywithin withinHeld$fHasHookHookmHooks$fHasHookEntryIOmkHooksButton HasButtonbutton pressAction releaseActionmkButtononPress onReleaseemitB pressOnly releaseOnlymodded layerToggle layerSwitchlayerAddlayerRempass cmdButton aroundNextaroundNextTimeoutaroundNextSingletapOntapHoldtapNext tapHoldNextbeforeAfterNexttapNextReleasetapHoldNextRelease tapNextPressmultiTaptapMacrotapMacroRelease layerDelay layerNext stickyKey$fHasButtonButtonBEnv _beButton_binding _lastSwitchHasBEnvbEnvbeButtonbinding lastSwitchinitBEnvrunBEnv$fHasButtonBEnv $fHasBEnvBEnvKeymapmkKeymap lookupKey$fHasKeymapKeymap LinuxKeyEvent linuxKeyEventsyncfromLinuxKeyEventtoLinuxKeyEvent$fDisplayLinuxKeyEvent$fShowLinuxKeyEvent$fShowUinputSinkError$fExceptionUinputSinkError UinputCfg _vendorCode _productCode_productVersion _keyboardName _postInit"$fAsUinputSinkErrorUinputSinkError $fEqUinputCfg$fShowUinputCfg UinputSink keyboardNamepostInit productCodeproductVersion vendorCode defUinputCfg$fHasUinputCfgUinputCfg uinputSink$fShowDeviceSourceError$fExceptionDeviceSourceErrorKeyEventParser&$fAsDeviceSourceErrorDeviceSourceErrordecode64!$fHasKeyEventParserKeyEventParser#$fHasDeviceSourceCfgDeviceSourceCfg deviceSourcedeviceSource64$fHasKeyEventParserDeviceFile$fHasDeviceSourceCfgDeviceFile$fHasDeviceFileDeviceFileCfgToken_src_snk_km_fstL_flt_allow DefButtonKRefKEmit KPressOnly KReleaseOnly KLayerToggle KLayerSwitch KLayerAdd KLayerRemKTapNextKTapHold KTapHoldNextKTapNextReleaseKTapHoldNextRelease KTapNextPress KAroundNextKAroundNextSingle KMultiTapKAroundKAroundNextTimeout KTapMacroKTapMacroRelease KComposeSeqKPause KLayerDelay KLayerNextKCommand KStickyKeyKBeforeAfterNextKTransKBlock$fShowDefButton DefSettingSITokenSOTokenSCmpSeqSInitStr SFallThrough SAllowCmd SCmpSeqDelayOToken KUinputSinkKSendEventSink KKextSinkIToken KDeviceSourceKLowLevelHookSource KIOKitSourceDefLayer _layerName_buttonsDefAliasDefSrc$fHasCfgTokenCfgToken$fShowDefSetting $fShowOToken $fShowIToken$fShowDefLayerKExprKDefCfgKDefSrc KDefLayer KDefAlias DefSettings AsDefSetting _DefSetting_SIToken_SOToken_SCmpSeq _SInitStr _SFallThrough _SAllowCmd _SCmpSeqDelay$fEqDefSetting$fAsDefSettingDefSetting $fShowKExprAsKExpr_KExpr_KDefCfg_KDefSrc _KDefLayer _KDefAlias$fAsKExprKExpr$fExceptionJoinError$fShowJoinError joinConfigIO joinConfig $fFunctorJ$fApplicativeJ$fMonadJ$fMonadErrorJoinErrorJ$fMonadReaderJCfgJ _keySinkDev _keySourceDev _keymapCfg _firstLayer _fallThrough _allowCmd _startDelayAppEnv _keAppCfg _keLogFunc_keySink _keySource _dispatch_inHooks_sluice_keymap _outHooks_outVar HasAppCfgappCfgallowCmd fallThrough firstLayer keySinkDev keySourceDev keymapCfg startDelay$fHasAppCfgAppCfgKEnv_kAppEnv_kBEnv HasAppEnvappEnvdispatchinHookskeAppCfg keLogFunckeySink keySourcekeymapoutHooksoutVarsluice$fHasAppCfgAppEnv$fHasLogFuncAppEnv$fHasAppEnvAppEnvHasKEnvkEnvkAppEnvkBEnv $fMonadKIORIO $fMonadKRIO$fHasLogFuncKEnv $fHasBEnvKEnv$fHasAppEnvKEnv$fHasAppCfgKEnv $fHasKEnvKEnv parseTokens loadTokenssymbolnumPkeywordButtonsnoKeywordButtonsitokensotokensversiongetDataFileName getBinDir getLibDir getDynLibDir getDataDir getLibexecDir getSysconfDirCmd_cfgFile_dryRun_logLvl_strtDel _cmdAllow _fallThrgh_initStr_cmpSeq_oToken_iToken $fShowCmdHasCmdcmdcfgFilecmdAllowcmpSeqdryRun fallThrghiTokeninitStrlogLvloTokenstrtDelgetCmd $fHasCmdCmd loadConfigmainText.Megaparsec.CharcharText.Megaparsec.Commonstringstring'space1 spaceCharspacenewlinecrlfeoltabhspacehspace1 controlChar upperChar lowerChar letterChar alphaNumChar printChar digitChar binDigitChar octDigitChar hexDigitCharmarkChar numberCharpunctuationChar symbolChar separatorChar asciiChar latin1Char charCategory categoryNamechar'_stack_maps_itemsCanKeyCanMMkcAll kcNotMissingnameKCaliases_switch_keycode _eventSrc_blocked _blockBuf mkSluice'step _readProc _rerunBuf mkDispatch' _injectTmr_hooksmkHooks'ioHook cancelHookrunEntryrunHooks _pressAction_releaseActionpress mkKeymap' debugReport time-1.12.2#Data.Time.Clock.Internal.SystemTime SystemTimeUinputSinkErrorUinputRegistrationErrorUinputReleaseErrorSinkEncodeErrorEmptyNameErroracquire_uinput_keysinkrelease_uinput_keysink send_eventusOpenusCloseusWritec_acquire_uinput_keysink_nbytes_prsioctl_keyboardDeviceSourceCfg_pth_parserdefEventParser DeviceFile_cfg_fd_hdllsOpenIOCtlGrabErrorlsCloseIOCtlReleaseErrorlsReadKeyIODecodeErrorJCfg_cmpKey_kes JoinErrorJrunJextractonlyOneoneBlock joinConfig' getOverriderunLFgetIgetOgetFTgetAllowgetCmpSeqDelay pickInput pickOutput joinAliasesunnest joinButton joinKeymap joinLayerlexeme terminatorsword terminatedprefix fromNamedparen statementkeywordPkeycodePtextPderefPconfigPexprsPexprP shiftedNames buttonNamesmoddedPpauseP rmTapMacroP composeSeqP deadkeySeqPbuttonPitokenPotokenPdefcfgPsettingP defaliasP versionercmdPfilePdryrunPlevelP cmdAllowP fallThrghPinitStrPcmpSeqPoTokenPiTokenP startDelayP tokenParser megaReadMjoinCLIrunCmd initAppEnvpressKeyloopstartApp