h*'      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                                            0.5.0.2 Safe-Inferred "-' flatparse  isDigit c = '0' <= c && c <= '9' flatparse isLatinLetter c = ('A' <= c && c <= 'Z') || ('a' <= c && c <= 'z') flatparse isGreekLetter c = ('' <= c && c <= '') || ('' <= c && c <= '')  flatparse*Shortcut for 'indexCharOffAddr# addr# 0#'.  flatparse Coerce a  to .  flatparse Coerce a  to .  flatparse Coerce a  to .  flatparseAssert for the given  that n >= 0.3Throws a runtime error if given a negative integer. flatparse Unwrap the  from an $ and apply it to the given function. flatparseConvert an UTF8-encoded  to a . flatparse Convert a  to an UTF8-encoded . flatparseIndex of leftmost null byte, or (number of bytes in type) if not present.Adapted from Hacker's Delight 6-1. Useful in big-endian environments. flatparse6bit mangling, returns 0 for inputs without a null byteSeparating allows us to skip some index calculation if there was no null byte. flatparse4bit mangling, turns intermediate value into an indexSeparating allows us to skip some index calculation if there was no null byte. flatparseIndex of rightmost null byte, or (number of bytes in type) if not presentAdapted from Hacker's Delight 6-1. Useful in little-endian environments. flatparse6bit mangling, returns 0 for inputs without a null byteSeparating allows us to skip some index calculation if there was no null byte. flatparse4bit mangling, turns intermediate value into an indexSeparating allows us to skip some index calculation if there was no null byte.   Safe-Inferred "-1   Safe-Inferred"-E flatparse4Parse a non-empty ASCII decimal digit sequence as a . Fails on overflow. flatparse=Parse a non-empty ASCII decimal digit sequence as a positive . Fails on overflow. flatparse=Parse a non-empty ASCII decimal digit sequence as a positive . May overflow. flatparse=Parse a non-empty ASCII decimal digit sequence as a positive . flatparse=Parse a non-empty ASCII decimal digit sequence as a positive . May overflow. flatparseParse a non-empty, case-insensitive ASCII hexadecimal digit sequence as a . Fails on overflow.  flatparseParse a non-empty, case-insensitive ASCII hexadecimal digit sequence as a positive . Fails on overflow.' flatparse,protobuf style (LE, redundant, on continues) !"#$%&'() !"#$%&'() Safe-Inferred "-,+*,+* Safe-Inferred"-1& - flatparsePrimitive parser result.. flatparse3Primitive parser result wrapped with a state token.You should rarely need to manipulate values of this type directly. Use the provided bidirectional pattern synonyms 7, 6 and 5./ flatparse$The type of parsers which can embed ST actions.0 flatparse$The type of parsers which can embed  actions.1 flatparseThe type of pure parsers.2 flatparseParserT st e a% is a parser with a state token type st, an error type e and a return type a. The different state token types support different embedded effects; see 1, 0 and / below.5 flatparse. constructor for errors which are by default non-recoverable. Contains the error, plus a state token.6 flatparse. constructor for recoverable failure. Contains only a state token.7 flatparse. constructor for a successful parse. Contains the return value and a pointer to the rest of the input buffer, plus a state token.8 flatparseChoose between two parsers. If the first parser fails, try the second one, but if the first one throws an error, propagate the error. This operation can arbitrarily backtrack.Note: this exported operator has different fixity than the same operator in -. Hide this operator if you want to use the  Alternative version.: flatparseBy default, parser choice 8* arbitrarily backtracks on parser failure.> flatparseYou may lift IO actions into a 0 using . 23410/.756-8 23410/.756-886 Safe-Inferred "-;$? flatparse.The failing parser. By default, parser choice 8- arbitrarily backtracks on parser failure.@ flatparse1Throw a parsing error. By default, parser choice 8) can't backtrack on parser error. Use B. to convert an error to a recoverable failure.A flatparseRun the parser, if an error is thrown, handle it with the given function.B flatparse%Convert a parsing error into failure.C flatparse'Convert a parsing failure to a success.D flatparse&Convert a parsing failure to an error.E flatparseRun the parser, if we get a failure, throw the given error, but if we get an error, merge the inner and the newly given errors using the  e -> e -> e function. This can be useful for implementing parsing errors which may propagate hints or accummulate contextual information.F flatparseConvert a parsing failure to a . If possible, use H instead.G flatparseConvert a parsing failure to a ().H flatparseCPS'd version of F. This is usually more efficient, since it gets rid of the extra  allocation.I flatparseSucceed if the input is empty.J flatparseSave the parsing state, then run a parser, then restore the state.K flatparse isolate n p runs the parser p isolated to the next n/ bytes. All isolated bytes must be consumed.3Throws a runtime error if given a negative integer.L flatparse isolate# n# p runs the parser p isolated to the next n#/ bytes. All isolated bytes must be consumed.3Throws a runtime error if given a negative integer.M flatparseisolateUnsafe# n# p runs the parser p isolated to the next n#/ bytes. All isolated bytes must be consumed.0Undefined behaviour if given a negative integer.N flatparseAn analogue of the list  function: first parse a b, then parse zero or more a;-s, and combine the results in a left-nested way by the  b -> a -> b* function. Note: this is not the usual N$ function from the parsec libraries!O flatparseAn analogue of the list  function: parse zero or more a-s, terminated by a b=, and combine the results in a right-nested way using the  a -> b -> b* function. Note: this is not the usual O$ function from the parsec libraries!P flatparseBranch on a parser: if the first argument succeeds, continue with the second, else with the third. This can produce slightly more efficient code than 8 . Moreover, P1 does not backtrack from the true/false cases.Q flatparse>Succeed if the first parser succeeds and the second one fails.R flatparseAssert that there are at least n bytes remaining.0Undefined behaviour if given a negative integer.S flatparseAssert that there are at least n# bytes remaining.0Undefined behaviour if given a negative integer.T flatparseAssert that there are at least n# bytes remaining (CPS).0Undefined behaviour if given a negative integer.U flatparse5Assert that there is at least 1 byte remaining (CPS).0Undefined behaviour if given a negative integer.V flatparseAssert that there are at least n# bytes remaining (CPS).0Undefined behaviour if given a negative integer.W flatparse$Read the given number of bytes as a  ByteString.3Throws a runtime error if given a negative integer.This does no copying. The  returned is a "slice" of the input, and will keep it alive. To avoid this, use  on the output.X flatparseRead n# bytes as a  ByteString. Fails if fewer than n# bytes are available.3Throws a runtime error if given a negative integer.This does no copying. The  returned is a "slice" of the input, and will keep it alive. To avoid this, use  on the output.Y flatparseRead n# bytes as a  ByteString. Fails if fewer than n# bytes are available.0Undefined behaviour if given a negative integer.This does no copying. The  returned is a "slice" of the input, and will keep it alive. To avoid this, use  on the output.Z flatparse?Consume the rest of the input. May return the empty bytestring.This does no copying. The  returned is a "slice" of the input, and will keep it alive. To avoid this, use  on the output.[ flatparse Skip forward n bytes. Fails if fewer than n bytes are available.3Throws a runtime error if given a negative integer.\ flatparse Skip forward n# bytes. Fails if fewer than n# bytes are available.3Throws a runtime error if given a negative integer.] flatparseGo back i. bytes in the input. Takes a positive integer.?Extremely unsafe. Makes no checks. Almost certainly a Bad Idea.^ flatparseGo back n#! bytes. Takes a positive integer.?Extremely unsafe. Makes no checks. Almost certainly a Bad Idea._ flatparse Skip forward n#5 bytes and run the given parser. Fails if fewer than n# bytes are available.3Throws a runtime error if given a negative integer.` flatparse Skip forward n5 bytes and run the given parser. Fails if fewer than n bytes are available.0Undefined behaviour if given a negative integer.a flatparse!Skip a parser zero or more times.b flatparse Skip a parser one or more times.$IWXYZ[\]^_`PQNOJRSTUVKLMab?B@ACDEFGH$IWXYZ[\]^_`PQNOJRSTUVKLMab?B@ACDEFGH Safe-Inferred "-I)c flatparseHelper for defining CPS parsers for types of a constant byte size (i.e. machine integers).Call this with an indexXYZOffAddr primop (e.g. 4) and the size in bytes of the type you're parsing.d flatparseUnsafe helper for defining CPS parsers for types of a constant byte size (i.e. machine integers).Is really just syntactic sugar for applying the given parser and shifting the buffer along.:The caller must guarantee that the input has enough bytes.e flatparse Parse any  (CPS).f flatparse Parse any  (native byte order) (CPS).g flatparse Parse any  (native byte order) (CPS).h flatparse Parse any  (native byte order) (CPS).i flatparse Parse any  (CPS).j flatparse Parse any  (native byte order) (CPS).k flatparse Parse any  (native byte order) (CPS).l flatparse Parse any  (native byte order) (CPS).m flatparse Parse any  (native size) (CPS).n flatparse Parse any  (native size) (CPS).o flatparse Parse any .p flatparse Parse any  (native byte order).q flatparse Parse any  (native byte order).r flatparse Parse any  (native byte order).s flatparse Parse any .t flatparse Parse any  (native byte order).u flatparse Parse any  (native byte order).v flatparse Parse any  (native byte order).w flatparse Parse any  (native size).x flatparse Parse any  (native size).y flatparse Parse any  (little-endian).z flatparse Parse any  (big-endian).{ flatparse Parse any  (little-endian).| flatparse Parse any  (big-endian).} flatparse Parse any  (little-endian).~ flatparse Parse any  (big-endian). flatparse Parse any  (little-endian). flatparse Parse any  (big-endian). flatparse Parse any  (little-endian). flatparse Parse any  (big-endian). flatparse Parse any  (little-endian). flatparse Parse any  (big-endian). flatparse/Read the next 1 byte and assert its value as a . flatparseUnsafe helper for defining parsers for types of a constant byte size (i.e. machine integers) which assert the parsed value's... value.Call this with an indexXYZOffAddr primop (e.g. ), the size in bytes of the type you're parsing, and the expected value to test the parsed value against.:The caller must guarantee that the input has enough bytes. flatparse8Unsafely read the next 1 byte and assert its value as a .:The caller must guarantee that the input has enough bytes. flatparse;Unsafely read the next 2 bytes and assert their value as a  (native byte order).:The caller must guarantee that the input has enough bytes. flatparse;Unsafely read the next 4 bytes and assert their value as a . (native byte order).:The caller must guarantee that the input has enough bytes. flatparse;Unsafely read the next 8 bytes and assert their value as a . (native byte order).:The caller must guarantee that the input has enough bytes. flatparseUnsafely parse any +, without asserting the input is non-empty.:The caller must guarantee that the input has enough bytes.)opqrstuvwxyz{|}~efghijklmncd)opqrstuvwxyz{|}~efghijklmncd Safe-Inferred "-K flatparseRead a sequence of bytes. This is a template function, you can use it as $(bytes [3, 4, 5])*, for example, and the splice has type  Parser e (). For a non-TH variant see . flatparseTemplate function, creates a  Parser e ()4 which unsafely parses a given sequence of bytes.:The caller must guarantee that the input has enough bytes.  Safe-Inferred "-X flatparseRun a parser, passing it the current address the parser is at.Useful for parsing offset-based data tables. For example, you may use this to save the base address to use together with various relative offsets. flatparsetakeOffAddr# addr# offset# len# moves to addr#, skips offset# bytes, reads len# bytes into a  ByteString', and restores the original address.The  should be from .Useful for parsing offset-based data tables. Ex: Your file contains an index storing (OFFSET, LENGTH) entries where the offset is the byte position in the file. Begin with  $ tableBase# -> ..., then read each entry like  tableBase# OFFSET LENGTH./Fails if you attempt to read outside the input.Undefined behaviour if offset# or len# is negative."Name adopted from the similar-ish indexXOffAddr# primops. flatparsewithOffAddr# addr# offset# p moves to addr#, skips offset#& bytes, then runs the given parser p.The  should be from ./Fails if you attempt to read outside the input.Undefined behaviour if offset# is negative."Name adopted from the similar-ish indexXOffAddr# primops. flatparseJ,, but specify the address to lookahead from.The  should be from . flatparse"Run a parser at the given address.The  should be from .6This is a highly internal function -- you likely want 9, which will reset the address after running the parser.  Safe-Inferred "-b flatparseA pair of positions. flatparseByte offset counted backwards from the end of the buffer. Note: the  instance for 2 considers the earlier positions to be smaller. flatparseVery unsafe conversion between a primitive address and a position. The first argument points to the end of the buffer, the second argument is being converted. flatparseVery unsafe conversion between a primitive address and a position. The first argument points to the end of the buffer. flatparse Slice into a  using a . The result is invalid if the / is not a valid slice of the first argument. flatparseThe end of the input.    Safe-Inferred "-d flatparseDecorate a trie with the minimum lengths of non-empty paths. This is used later to place  ensureBytes#. flatparseCompress linear paths. flatparseCompute where to fall back after we exhausted a branch. If the branch is empty, that means we've succeded at reading and we jump to the rhs rule. flatparseDecorate with  ensureBytes#, invocations, represented as `Maybe Int`.  Safe-Inferred "-m flatparseThis is a template function which makes it possible to branch on a collection of string literals in an efficient way. By using , such branching is compiled to a trie of primitive parsing operations, which has optimized control flow, vectorized reads and grouped checking for needed input bytes.7The syntax is slightly magical, it overloads the usual case expression. An example:  $(switch [| case _ of "foo" -> pure True "bar" -> pure False |]) The underscore is mandatory in  case _ of. Each branch must be a string literal, but optionally we may have a default case, like in  $(switch [| case _ of "foo" -> pure 10 "bar" -> pure 20 _ -> pure 30 |]) All case right hand sides must be parsers with the same type. That type is also the type of the whole  expression.A  has longest match semantics, and the order of cases does not matter, except for the default case, which may only appear as the last case.If a  does not have a default case, and no case matches the input, then it returns with failure, without having consumed any input. A fallthrough to the default case also does not consume any input. flatparseSwitch expression with an optional first argument for performing a post-processing action after every successful branch matching, not including the default branch. For example, if we have ws :: ParserT st e () for a whitespace parser, we might want to consume whitespace after matching on any of the switch cases. For that case, we can define a "lexeme" version of  as follows.  switch' :: Q Exp -> Q Exp switch' = switchWithPost (Just [| ws |]) Note that this switch' function cannot be used in the same module it's defined in, because of the stage restriction of Template Haskell. flatparse Version of  without syntactic sugar. The second argument is the list of cases, the third is the default case. Safe-Inferred"-1 flatparse1Higher-level boxed data type for parsing results. flatparse+Contains return value and unconsumed input. flatparseRecoverable-by-default failure. flatparseUnrecoverble-by-default error. flatparseEmbed an IO action in a 2. This is slightly safer than  because it will sequenced correctly with respect to the surrounding actions, and its execution is guaranteed. flatparse Run a parser. flatparseRun a parser on a 1, converting it to the corresponding UTF-8 bytes. Reminder: OverloadedStrings for 7 does not yield a valid UTF-8 encoding! For non-ASCII  literal input, use this wrapper or properly convert your input first. flatparseRun an -based parser. flatparseRun an -based parser. flatparseRun an  action in a /. flatparseRun a / inside a pure parser. flatparseParse a given .6If the bytestring is statically known, consider using bytes instead. flatparse&Get the current position in the input. flatparseSet the input position.Warning: this can result in crashes if the position points outside the current buffer. It is always safe to  values which came from  with the current input. flatparse%Return the consumed span of a parser. flatparseBind the result together with the span of the result. CPS'd version of  for better unboxing. flatparse Return the 8 consumed by a parser. Note: it's more efficient to use  and  instead. flatparseCPS'd version of . Can be more efficient, because the result is more eagerly unboxed by GHC. It's more efficient to use  or  instead. flatparseRun a parser in a given input .The input position is restored after the parser is finished, so 0 does not consume input and has no side effect.Warning: this operation may crash if the given span points outside the current parsing buffer. It's always safe to use  if the  comes from a previous  or  call on the current input. flatparse Create a  from a .The result is invalid if the / points outside the current buffer, or if the ( start is greater than the end position. flatparseCheck whether a  points into a . flatparse7Compute corresponding line and column numbers for each  in a list, assuming UTF8 encoding. Throw an error on invalid positions. Note: computing lines and columns may traverse the , but it traverses it only once regardless of the length of the position list. flatparse Create a  from a line and column number. Throws an error on out-of-bounds line and column numbers. flatparseBreak an UTF-8-coded  to lines. Throws an error on invalid input. This is mostly useful for grabbing specific source lines for displaying error messages. flatparse>Isolate the given parser up to (excluding) the next null byte.Like K, all isolated bytes must be consumed. The null byte is consumed afterwards.5Useful for defining parsers for null-terminated data. flatparse5Read a null-terminated bytestring (a C-style string).Consumes the null terminator. flatparseRead a null-terminated bytestring (a C-style string), where the bytestring is known to be null-terminated somewhere in the input.Highly unsafe. Unless you have a guarantee that the string will be null terminated before the input ends, use  instead. Honestly, I'm not sure if this is a good function to define. But here it is.Fails on GHC versions older than 9.0, since we make use of the  primop introduced in GHC 9.0, and we aren't very useful without it.Consumes the null terminator. flatparse-Read a protobuf-style varint into a positive .protobuf-style varints are byte-aligned. For each byte, the lower 7 bits are data and the MSB indicates if there are further bytes. Once fully parsed, the 7-bit payloads are concatenated and interpreted as a little-endian unsigned integer.)Fails if the varint exceeds the positive  range.Really, these are varnats. They also match with the LEB128 varint encoding.protobuf encodes negatives in unsigned integers using zigzag encoding. See the  fromZigzag, family of functions for this functionality.Further reading: https://developers.google.com/protocol-buffers/docs/encoding#varints23410/.756-IWXYZ[\]^_`8PQNOJRSTUVKLMab?B@ACDEFGHopqrstuvwxyz{|}~efghijklmncd23410/.756-IWXYZ[\]^_`8PQNOJRSTUVKLMab?B@ACDEFGH Safe-Inferred "-/ flatparseA parsing error. flatparse:A precisely known error, like leaving out "in" from "let". flatparseAn imprecise error, when we expect a number of different things, but parse something else. flatparse6An expected item which is displayed in error messages. flatparseAn error message. flatparseA literal expected thing. flatparseMerge two errors. Inner errors (which were thrown at points with more consumed inputs) are preferred. If errors are thrown at identical input positions, we prefer precise errors to imprecise ones.The point of prioritizing inner and precise errors is to suppress the deluge of "expected" items, and instead try to point to a concrete issue to fix. flatparsePretty print an error. The  input is the source file. The offending line from the source is displayed in the output. flatparse7Imprecise cut: we slap a list of items on inner errors. flatparse1Precise cut: we propagate at most a single error. flatparse*Run parser, print pretty error on failure. flatparseParse a line comment. flatparse-Parse a potentially nested multiline comment. flatparseConsume whitespace. flatparse*Consume whitespace after running a parser. flatparse+Read a starting character of an identifier. flatparse/Read a non-starting character of an identifier. flatparseCheck whether a ; contains exactly a keyword. Does not change parsing state. flatparseParse a non-keyword string. flatparse e -> e function. This can be useful for implementing parsing errors which may propagate hints or accummulate contextual information. flatparseConvert a parsing failure to a . If possible, use  instead. flatparseConvert a parsing failure to a (). flatparseCPS'd version of . This is usually more efficient, since it gets rid of the extra  allocation. flatparseSucceed if the input is empty. flatparseSave the parsing state, then run a parser, then restore the state. flatparse isolate n p runs the parser p isolated to the next n/ bytes. All isolated bytes must be consumed.3Throws a runtime error if given a negative integer. flatparse isolate# n# p runs the parser p isolated to the next n#/ bytes. All isolated bytes must be consumed.3Throws a runtime error if given a negative integer. flatparseisolateUnsafe# i# p runs the parser p isolated to the next i#/ bytes. All isolated bytes must be consumed.0Undefined behaviour if given a negative integer. flatparseAn analogue of the list  function: first parse a b, then parse zero or more a;-s, and combine the results in a left-nested way by the  b -> a -> b* function. Note: this is not the usual $ function from the parsec libraries! flatparseAn analogue of the list  function: parse zero or more a-s, terminated by a b=, and combine the results in a right-nested way using the  a -> b -> b* function. Note: this is not the usual $ function from the parsec libraries! flatparseBranch on a parser: if the first argument succeeds, continue with the second, else with the third. This can produce slightly more efficient code than  . Moreover, Succeed if the first parser succeeds and the second one fails. flatparseAssert that there are at least n bytes remaining.0Undefined behaviour if given a negative integer. flatparseAssert that there are at least n# bytes remaining.0Undefined behaviour if given a negative integer. flatparseAssert that there are at least n# bytes remaining (CPS).0Undefined behaviour if given a negative integer. flatparse5Assert that there is at least 1 byte remaining (CPS).0Undefined behaviour if given a negative integer. flatparseAssert that there are at least n# bytes remaining (CPS).0Undefined behaviour if given a negative integer. flatparseRead n bytes as a  ByteString. Fails if fewer than n bytes are available.3Throws a runtime error if given a negative integer.This does no copying. The  returned is a "slice" of the input, and will keep it alive. To avoid this, use  on the output. flatparseRead n# bytes as a  ByteString. Fails if fewer than n# bytes are available.3Throws a runtime error if given a negative integer.This does no copying. The  returned is a "slice" of the input, and will keep it alive. To avoid this, use  on the output. flatparseRead i# bytes as a  ByteString. Fails if newer than i# bytes are available.0Undefined behaviour if given a negative integer.This does no copying. The  returned is a "slice" of the input, and will keep it alive. To avoid this, use  on the output. flatparse?Consume the rest of the input. May return the empty bytestring.This does no copying. The  returned is a "slice" of the input, and will keep it alive. To avoid this, use  on the output. flatparse Skip forward n bytes. Fails if fewer than n bytes are available.3Throws a runtime error if given a negative integer. flatparse Skip forward n bytes. Fails if fewer than n bytes are available.3Throws a runtime error if given a negative integer. flatparseGo back i. bytes in the input. Takes a positive integer.?Extremely unsafe. Makes no checks. Almost certainly a Bad Idea. flatparseGo back i#. bytes in the input. Takes a positive integer.?Extremely unsafe. Makes no checks. Almost certainly a Bad Idea. flatparse Skip forward n#5 bytes and run the given parser. Fails if fewer than n# bytes are available.3Throws a runtime error if given a negative integer. flatparse Skip forward i#5 bytes and run the given parser. Fails if fewer than i bytes are available.0Undefined behaviour if given a negative integer. flatparse!Skip a parser zero or more times. flatparse Skip a parser one or more times.$$ Safe-Inferred "-k) flatparseHelper for defining CPS parsers for types of a constant byte size (i.e. machine integers).Call this with an indexXYZOffAddr primop (e.g. 4) and the size in bytes of the type you're parsing. flatparseUnsafe helper for defining CPS parsers for types of a constant byte size (i.e. machine integers).Is really just syntactic sugar for applying the given parser and shifting the buffer along.:The caller must guarantee that the input has enough bytes. flatparse Parse any  (CPS). flatparse Parse any  (native byte order) (CPS). flatparse Parse any  (native byte order) (CPS). flatparse Parse any  (native byte order) (CPS). flatparse Parse any  (CPS). flatparse Parse any  (native byte order) (CPS). flatparse Parse any  (native byte order) (CPS). flatparse Parse any  (native byte order) (CPS). flatparse Parse any  (native size) (CPS). flatparse Parse any  (native size) (CPS). flatparse Parse any . flatparse Parse any  (native byte order). flatparse Parse any  (native byte order). flatparse Parse any  (native byte order). flatparse Parse any . flatparse Parse any  (native byte order). flatparse Parse any  (native byte order). flatparse Parse any  (native byte order). flatparse Parse any  (native size). flatparse Parse any  (native size). flatparse Parse any  (little-endian). flatparse Parse any  (big-endian). flatparse Parse any  (little-endian). flatparse Parse any  (big-endian). flatparse Parse any  (little-endian). flatparse Parse any  (big-endian). flatparse Parse any  (little-endian). flatparse Parse any  (big-endian). flatparse Parse any  (little-endian). flatparse Parse any  (big-endian). flatparse Parse any  (little-endian). flatparse Parse any  (big-endian). flatparse/Read the next 1 byte and assert its value as a . flatparseUnsafe helper for defining parsers for types of a constant byte size (i.e. machine integers) which assert the parsed value's... value.Call this with an indexXYZOffAddr primop (e.g. ), the size in bytes of the type you're parsing, and the expected value to test the parsed value against.:The caller must guarantee that the input has enough bytes. flatparse8Unsafely read the next 1 byte and assert its value as a .:The caller must guarantee that the input has enough bytes. flatparse;Unsafely read the next 2 bytes and assert their value as a  (native byte order).:The caller must guarantee that the input has enough bytes. flatparse;Unsafely read the next 4 bytes and assert their value as a . (native byte order).:The caller must guarantee that the input has enough bytes. flatparse;Unsafely read the next 8 bytes and assert their value as a . (native byte order).:The caller must guarantee that the input has enough bytes. flatparseUnsafely parse any +, without asserting the input is non-empty.:The caller must guarantee that the input has enough bytes.)) Safe-Inferred "- flatparseRead a sequence of bytes. This is a template function, you can use it as $(bytes [3, 4, 5])', for example, and the splice has type Parser e (). For a non-TH variant see . flatparseTemplate function, creates a  Parser e ()4 which unsafely parses a given sequence of bytes.:The caller must guarantee that the input has enough bytes. Safe-Inferred "-] flatparse>Run a parser, passing it the current address the parser is at.Useful for parsing offset-based data tables. For example, you may use this to save the base address to use together with various relative offsets. flatparsetakeOffAddr# addr# offset# len# moves to addr#, skips offset# bytes, reads len# bytes into a  ByteString', and restores the original address.The  should be from .Useful for parsing offset-based data tables. Ex: Your file contains an index storing (OFFSET, LENGTH) entries where the offset is the byte position in the file. Begin with  $ tableBase# -> ..., then read each entry like  tableBase# OFFSET LENGTH./Fails if you attempt to read outside the input.Undefined behaviour if offset# or len# is negative."Name adopted from the similar-ish indexXOffAddr# primops. flatparsewithOffAddr# addr# offset# p moves to addr#, skips offset#& bytes, then runs the given parser p.The  should be from ./Fails if you attempt to read outside the input.Undefined behaviour if offset# is negative."Name adopted from the similar-ish indexXOffAddr# primops. flatparse,, but specify the address to lookahead from.The  should be from . flatparse"Run a parser at the given address.The  should be from .6This is a highly internal function -- you likely want 9, which will reset the address after running the parser. Safe-Inferred "-l flatparseThis is a template function which makes it possible to branch on a collection of string literals in an efficient way. By using , such branching is compiled to a trie of primitive parsing operations, which has optimized control flow, vectorized reads and grouped checking for needed input bytes.7The syntax is slightly magical, it overloads the usual case expression. An example:  $(switch [| case _ of "foo" -> pure True "bar" -> pure False |]) The underscore is mandatory in  case _ of. Each branch must be a string literal, but optionally we may have a default case, like in  $(switch [| case _ of "foo" -> pure 10 "bar" -> pure 20 _ -> pure 30 |]) All case right hand sides must be parsers with the same type. That type is also the type of the whole  expression.A  has longest match semantics, and the order of cases does not matter, except for the default case, which may only appear as the last case.If a  does not have a default case, and no case matches the input, then it returns with failure, without having consumed any input. A fallthrough to the default case also does not consume any input. flatparseSwitch expression with an optional first argument for performing a post-processing action after every successful branch matching. For example, if we have ws :: ParserT st r e () for a whitespace parser, we might want to consume whitespace after matching on any of the switch cases. For that case, we can define a "lexeme" version of  as follows.  switch' :: Q Exp -> Q Exp switch' = switchWithPost (Just [| ws |]) Note that this switch' function cannot be used in the same module it's defined in, because of the stage restriction of Template Haskell. flatparse Version of  without syntactic sugar. The second argument is the list of cases, the third is the default case. Safe-Inferred "-z flatparse literal input, use this wrapper or convert your input using  strToUtf8. flatparseRun an -based parser. The  argument is the initial state. flatparseRun an -based parser. The  argument is the initial state. flatparseRun a  inside a pure parser. flatparseRun an  action in a . flatparse Query the  state. flatparse Write the  state. flatparse Modify the  state. flatparseQuery the environment. flatparse'Run a parser in a modified environment. flatparseParse a given 8. If the bytestring is statically known, consider using bytes instead. flatparse&Get the current position in the input. flatparseSet the input position.Warning: this can result in crashes if the position points outside the current buffer. It is always safe to  values which came from  with the current input. flatparse*Return the consumed span of a parser. Use # if possible for better efficiency. flatparseBind the result together with the span of the result. CPS'd version of  for better unboxing. flatparse Return the 8 consumed by a parser. Note: it's more efficient to use  and  instead. flatparseCPS'd version of . Can be more efficient, because the result is more eagerly unboxed by GHC. It's more efficient to use  or  instead. flatparseRun a parser in a given input .The input position and the parser state is restored after the parser is finished, so / does not consume input and has no side effect.Warning: this operation may crash if the given span points outside the current parsing buffer. It's always safe to use  if the  comes from a previous  or  call on the current input. flatparse Create a  from a .The result is invalid if the / points outside the current buffer, or if the ( start is greater than the end position. flatparse>Isolate the given parser up to (excluding) the next null byte.Like , all isolated bytes must be consumed. The null byte is consumed afterwards.5Useful for defining parsers for null-terminated data. flatparse5Read a null-terminated bytestring (a C-style string).Consumes the null terminator. flatparseRead a null-terminated bytestring (a C-style string), where the bytestring is known to be null-terminated somewhere in the input.Highly unsafe. Unless you have a guarantee that the string will be null terminated before the input ends, use  instead. Honestly, I'm not sure if this is a good function to define. But here it is.Fails on GHC versions older than 9.0, since we make use of the  primop introduced in GHC 9.0, and we aren't very useful without it.Consumes the null terminator. flatparse-Read a protobuf-style varint into a positive .protobuf-style varints are byte-aligned. For each byte, the lower 7 bits are data and the MSB indicates if there are further bytes. Once fully parsed, the 7-bit payloads are concatenated and interpreted as a little-endian unsigned integer.)Fails if the varint exceeds the positive  range.Really, these are varnats. They also match with the LEB128 varint encoding.protobuf encodes negatives in unsigned integers using zigzag encoding. See the  fromZigzag, family of functions for this functionality.Further reading: https://developers.google.com/protocol-buffers/docs/encoding#varints! Safe-Inferred "-"#$"#%"#&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                                            UgQRSTUVVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~"""""""#""""""""""""""""""""""#"#""                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "#"#"#"#"#"#"#""""""""""""""""""""""""""""""""""!!!!!!!!(flatparse-0.5.0.2-JI7nShSbwS1CudyMU1zVa8FlatParse.BasicFlatParse.Common.AssortedFlatParse.Common.NumbersFlatParse.Common.ParserFlatParse.Basic.ParserFlatParse.Basic.BaseFlatParse.Basic.IntegersFlatParse.Basic.BytesFlatParse.Basic.TextFlatParse.Basic.AddrFlatParse.Common.PositionFlatParse.Common.SwitchFlatParse.Basic.Switch$FlatParse.Examples.BasicLambda.Lexer%FlatParse.Examples.BasicLambda.ParserFlatParse.Stateful.ParserFlatParse.Stateful.BaseFlatParse.Stateful.IntegersFlatParse.Stateful.BytesFlatParse.Stateful.AddrFlatParse.Stateful.SwitchFlatParse.Stateful.TextFlatParse.Stateful flatparseFlatParse.Common.GHCExtsControl ApplicativeGHC.ExtsindexWord8OffAddr byteString Data.CharisLetterPaths_flatparsebaseGHC.Baseemptysomemany shortIntegerisDigit isLatinLetter isGreekLetter packBytes splitBytes derefChar8# word16ToInt16 word32ToInt32 word64ToInt64 withPosInt#withIntUnwrap# charToBytes strToBytes strToUtf8 utf8ToStrzbytelzbytel'intermediate zbytel'toIdxzbyterzbyter'intermediate zbyter'toIdxanyAsciiDecimalWord#anyAsciiDecimalInt#anyAsciiDecimalWord_#anyAsciiDecimalIntOverflow#anyAsciiDecimalInteger#anyAsciiDecimalIntOverflow_#anyAsciiHexWord#anyAsciiHexInt#anyAsciiHexWord_#fromZigzagNativefromZigzagNative#toZigzagNativetoZigzagNative#toZigzagNative'#anyVarintProtobuf#unI#mul10#STModeIOModePureModeResI#Res#ParserSTParserIOParserParserT runParserT#Err#Fail#OK#<|>$fMonadPlusParserT$fAlternativeParserT$fMonadParserT$fApplicativeParserT$fFunctorParserT$fMonadIOParserTfailederr withErrortryfailscutcuttingoptional optional_ withOptioneof lookaheadisolateisolate#isolateUnsafe#chainlchainrbranch notFollowedByensureensure# withEnsure withEnsure1 withEnsure#taketake# takeUnsafe#takeRestskipskip#skipBack skipBack#atSkip# atSkipUnsafe#skipManyskipSome withAnySized#withAnySizedUnsafe# withAnyWord8 withAnyWord16 withAnyWord32 withAnyWord64 withAnyInt8 withAnyInt16 withAnyInt32 withAnyInt64 withAnyWord withAnyIntanyWord8 anyWord16 anyWord32 anyWord64anyInt8anyInt16anyInt32anyInt64anyWordanyInt anyWord16le anyWord16be anyWord32le anyWord32be anyWord64le anyWord64be anyInt16le anyInt16be anyInt32le anyInt32be anyInt64le anyInt64beword8 sizedUnsafe# word8Unsafe word16Unsafe word32Unsafe word64UnsafeanyWord8Unsafebytes bytesUnsafeanyChar skipAnyCharsatisfy skipSatisfy satisfyAsciiskipSatisfyAscii fusedSatisfyskipFusedSatisfyanyAsciiDecimalWordanyAsciiDecimalIntanyAsciiDecimalIntegeranyAsciiHexWordanyAsciiHexInt anyAsciiCharskipAnyAsciiCharcharstringtakeLine traceLinetakeRestString traceRest withAddr# takeOffAddr# withOffAddr#lookaheadFromAddr#atAddr#SpanPosunPos addrToPos# posToAddr# unsafeSliceendPos$fOrdPos$fEqSpan $fShowSpan $fShowPos$fEqPosTrie'Branch'PathRuleTrieBranchnilTrieupdRuleinsert listToTrie mindepthspathify fallbacks ensureBytes compileTrie $fShowTrie' $fShowTrieswitchswitchWithPostrawSwitchWithPostResultOKFailErr unsafeLiftIO runParser runParserUtf8 runParserST runParserIOliftST embedParserSTgetPossetPosspanOfwithSpan byteStringOfwithByteStringinSpanunsafeSpanToByteStringvalidPos posLineColsmkPos linesUtf8isolateToNextNull anyCStringanyCStringUnsafeanyVarintProtobuf$fFunctorResult $fShowResultErrorPrecise ImpreciseExpectedMsgLiterrorPosmerge prettyErrorcut' testParser lineCommentmultilineCommentwstokenidentStartChar identChar isKeywordsymbolsymbol'keywordkeyword'$fIsStringExpected $fShowError $fEqExpected$fShowExpected $fOrdExpectedTmVarAppLamLetBoolLitIntLitIfAddMulEqLtNameidentident'digitintatomatom'app'mul'add'eqLt'pLetlampIftm'src'p1$fShowTmgetputmodifyasklocalGHC.WordWord16GHC.IntInt16Word32Int32Word64Int64ghc-primGHC.PrimInt# GHC.TypesIntStringbytestring-0.11.5.2Data.ByteString.Internal.Type ByteStringI#FloatF#CharC#Addr#Array# ByteArray# SmallArray#Char#Double#Float#Int8#Int16#Int32#Int64#BCOWeak# MutableArray#MutableByteArray#SmallMutableArray#MVar#IOPort#TVar#MutVar# RealWorld StablePtr# StableName#Compact#State#Proxy# ThreadId#Word#Word8#Word16#Word32#Word64#StackSnapshot# PromptTag#FUNTYPE CONSTRAINTInt8X16#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#WordBox MkWordBoxIntBoxMkIntBoxFloatBox MkFloatBox DoubleBox MkDoubleBoxDictBox MkDictBoxBoolFalseTrueDoubleD#WordW#ListOrderingLTEQGT~~~ CoercibleSymbol RuntimeRepVecRepTupleRepSumRepBoxedRepIntRepInt8RepInt16RepInt32RepInt64RepWordRepWord8Rep Word16Rep Word32Rep Word64RepAddrRepFloatRep DoubleRepLevityLiftedUnliftedVecCountVec2Vec4Vec8Vec16Vec32Vec64VecElem Int8ElemRep Int16ElemRep Int32ElemRep Int64ElemRep Word8ElemRep Word16ElemRep Word32ElemRep Word64ElemRep FloatElemRep DoubleElemRep MultiplicityOneManySPECSPEC2 ZeroBitType ZeroBitRep UnliftedRep LiftedRep UnliftedType ConstraintAnyGHC.PtrPtr GHC.IsListIsListItemfromList fromListNtoListGHC.Magic.DictWithDictwithDict Data.StringIsString fromStringFunPtrVoid#MultMulData.OrdDowngetDownGHC.ArrayArrayMutableArrayArray# ArrayArray#SpecConstrAnnotation NoSpecConstrForceSpecConstr TypeLitChar TypeLitNat TypeLitSymbolKindRepTypeLitDKindRepTypeLitS KindRepTYPE KindRepFun KindRepApp KindRepVarKindRepTyConAppTrNameDTrNameScoerceaugmentbuildseq realWorld# GHC.CStringunpackCStringUtf8#unpackCString#unpackAppendCString#unpackFoldrCString#void#cstringLength# nullAddr# leftSection rightSection GHC.MagiclazyoneShotrunRW#inlineconsiderAccessiblenoinlineproxy# Unsafe.Coerce unsafeCoerce#gtChar#geChar#eqChar#neChar#ltChar#leChar#ord# int8ToInt# intToInt8# negateInt8# plusInt8#subInt8# timesInt8# quotInt8#remInt8# quotRemInt8#uncheckedShiftLInt8#uncheckedShiftRAInt8#uncheckedShiftRLInt8# int8ToWord8#eqInt8#geInt8#gtInt8#leInt8#ltInt8#neInt8# word8ToWord# wordToWord8# plusWord8# subWord8# timesWord8# quotWord8# remWord8# quotRemWord8# andWord8#orWord8# xorWord8# notWord8#uncheckedShiftLWord8#uncheckedShiftRLWord8# word8ToInt8#eqWord8#geWord8#gtWord8#leWord8#ltWord8#neWord8# int16ToInt# intToInt16# negateInt16# plusInt16# subInt16# timesInt16# quotInt16# remInt16# quotRemInt16#uncheckedShiftLInt16#uncheckedShiftRAInt16#uncheckedShiftRLInt16#int16ToWord16#eqInt16#geInt16#gtInt16#leInt16#ltInt16#neInt16# word16ToWord# wordToWord16# plusWord16# subWord16# timesWord16# quotWord16# remWord16#quotRemWord16# andWord16# orWord16# xorWord16# notWord16#uncheckedShiftLWord16#uncheckedShiftRLWord16#word16ToInt16# eqWord16# geWord16# gtWord16# leWord16# ltWord16# neWord16# int32ToInt# intToInt32# negateInt32# plusInt32# subInt32# timesInt32# quotInt32# remInt32# quotRemInt32#uncheckedShiftLInt32#uncheckedShiftRAInt32#uncheckedShiftRLInt32#int32ToWord32#eqInt32#geInt32#gtInt32#leInt32#ltInt32#neInt32# word32ToWord# wordToWord32# plusWord32# subWord32# timesWord32# quotWord32# remWord32#quotRemWord32# andWord32# orWord32# xorWord32# notWord32#uncheckedShiftLWord32#uncheckedShiftRLWord32#word32ToInt32# eqWord32# geWord32# gtWord32# leWord32# ltWord32# neWord32# int64ToInt# intToInt64# negateInt64# plusInt64# subInt64# timesInt64# quotInt64# remInt64#uncheckedIShiftL64#uncheckedIShiftRA64#uncheckedIShiftRL64#int64ToWord64#eqInt64#geInt64#gtInt64#leInt64#ltInt64#neInt64# word64ToWord# wordToWord64# plusWord64# subWord64# timesWord64# quotWord64# remWord64#and64#or64#xor64#not64#uncheckedShiftL64#uncheckedShiftRL64#word64ToInt64# eqWord64# geWord64# gtWord64# leWord64# ltWord64# neWord64#+#-#*# timesInt2#mulIntMayOflo#quotInt#remInt# quotRemInt#andI#orI#xorI#notI# negateInt#addIntC#subIntC#>#>=#==#/=#<#<=#chr# int2Word# int2Float# int2Double# word2Float# word2Double#uncheckedIShiftL#uncheckedIShiftRA#uncheckedIShiftRL# plusWord# addWordC# subWordC# plusWord2# minusWord# timesWord# timesWord2# quotWord#remWord# quotRemWord# quotRemWord2#and#or#xor#not#uncheckedShiftL#uncheckedShiftRL# word2Int#gtWord#geWord#eqWord#neWord#ltWord#leWord#popCnt8# popCnt16# popCnt32# popCnt64#popCnt#pdep8#pdep16#pdep32#pdep64#pdep#pext8#pext16#pext32#pext64#pext#clz8#clz16#clz32#clz64#clz#ctz8#ctz16#ctz32#ctz64#ctz# byteSwap16# byteSwap32# byteSwap64# byteSwap# 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# readArray# writeArray# sizeofArray#sizeofMutableArray# indexArray#unsafeFreezeArray#unsafeThawArray# copyArray#copyMutableArray# cloneArray#cloneMutableArray# freezeArray# thawArray# casArray#newSmallArray#shrinkSmallMutableArray#readSmallArray#writeSmallArray#sizeofSmallArray#sizeofSmallMutableArray#getSizeofSmallMutableArray#indexSmallArray#unsafeFreezeSmallArray#unsafeThawSmallArray#copySmallArray#copySmallMutableArray#cloneSmallArray#cloneSmallMutableArray#freezeSmallArray#thawSmallArray#casSmallArray# newByteArray#newPinnedByteArray#newAlignedPinnedByteArray#isMutableByteArrayPinned#isByteArrayPinned#byteArrayContents#mutableByteArrayContents#shrinkMutableByteArray#resizeMutableByteArray#unsafeFreezeByteArray#sizeofByteArray#sizeofMutableByteArray#getSizeofMutableByteArray#indexCharArray#indexWideCharArray#indexIntArray#indexWordArray#indexAddrArray#indexFloatArray#indexDoubleArray#indexStablePtrArray#indexInt8Array#indexInt16Array#indexInt32Array#indexInt64Array#indexWord8Array#indexWord16Array#indexWord32Array#indexWord64Array#indexWord8ArrayAsChar#indexWord8ArrayAsWideChar#indexWord8ArrayAsInt#indexWord8ArrayAsWord#indexWord8ArrayAsAddr#indexWord8ArrayAsFloat#indexWord8ArrayAsDouble#indexWord8ArrayAsStablePtr#indexWord8ArrayAsInt16#indexWord8ArrayAsInt32#indexWord8ArrayAsInt64#indexWord8ArrayAsWord16#indexWord8ArrayAsWord32#indexWord8ArrayAsWord64#readCharArray#readWideCharArray# readIntArray#readWordArray#readAddrArray#readFloatArray#readDoubleArray#readStablePtrArray#readInt8Array#readInt16Array#readInt32Array#readInt64Array#readWord8Array#readWord16Array#readWord32Array#readWord64Array#readWord8ArrayAsChar#readWord8ArrayAsWideChar#readWord8ArrayAsInt#readWord8ArrayAsWord#readWord8ArrayAsAddr#readWord8ArrayAsFloat#readWord8ArrayAsDouble#readWord8ArrayAsStablePtr#readWord8ArrayAsInt16#readWord8ArrayAsInt32#readWord8ArrayAsInt64#readWord8ArrayAsWord16#readWord8ArrayAsWord32#readWord8ArrayAsWord64#writeCharArray#writeWideCharArray#writeIntArray#writeWordArray#writeAddrArray#writeFloatArray#writeDoubleArray#writeStablePtrArray#writeInt8Array#writeInt16Array#writeInt32Array#writeInt64Array#writeWord8Array#writeWord16Array#writeWord32Array#writeWord64Array#writeWord8ArrayAsChar#writeWord8ArrayAsWideChar#writeWord8ArrayAsInt#writeWord8ArrayAsWord#writeWord8ArrayAsAddr#writeWord8ArrayAsFloat#writeWord8ArrayAsDouble#writeWord8ArrayAsStablePtr#writeWord8ArrayAsInt16#writeWord8ArrayAsInt32#writeWord8ArrayAsInt64#writeWord8ArrayAsWord16#writeWord8ArrayAsWord32#writeWord8ArrayAsWord64#compareByteArrays#copyByteArray#copyMutableByteArray#copyByteArrayToAddr#copyMutableByteArrayToAddr#copyAddrToByteArray# setByteArray#atomicReadIntArray#atomicWriteIntArray# casIntArray# casInt8Array#casInt16Array#casInt32Array#casInt64Array#fetchAddIntArray#fetchSubIntArray#fetchAndIntArray#fetchNandIntArray#fetchOrIntArray#fetchXorIntArray# 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#atomicExchangeAddrAddr#atomicExchangeWordAddr#atomicCasAddrAddr#atomicCasWordAddr#atomicCasWord8Addr#atomicCasWord16Addr#atomicCasWord32Addr#atomicCasWord64Addr#fetchAddWordAddr#fetchSubWordAddr#fetchAndWordAddr#fetchNandWordAddr#fetchOrWordAddr#fetchXorWordAddr#atomicReadWordAddr#atomicWriteWordAddr# newMutVar# readMutVar# writeMutVar#atomicModifyMutVar2#atomicModifyMutVar_# casMutVar#catch#raise#raiseUnderflow#raiseOverflow# raiseDivZero#raiseIO#maskAsyncExceptions#maskUninterruptible#unmaskAsyncExceptions#getMaskingState# newPromptTag#prompt# control0# atomically#retry# catchRetry# catchSTM#newTVar# readTVar# readTVarIO# writeTVar#newMVar# takeMVar# tryTakeMVar#putMVar# tryPutMVar# readMVar# tryReadMVar# isEmptyMVar# newIOPort# readIOPort# writeIOPort#delay# waitRead# waitWrite#fork#forkOn# killThread#yield# myThreadId# labelThread#isCurrentThreadBound# noDuplicate# threadLabel# threadStatus# listThreads#mkWeak#mkWeakNoFinalizer#addCFinalizerToWeak# deRefWeak# finalizeWeak#touch#makeStablePtr#deRefStablePtr# eqStablePtr#makeStableName#stableNameToInt# compactNew#compactResize#compactContains#compactContainsAny#compactGetFirstBlock#compactGetNextBlock#compactAllocateBlock#compactFixupPointers# compactAdd#compactAddWithSharing# compactSize#reallyUnsafePtrEquality#par#spark#seq# getSpark# numSparks# keepAlive# dataToTag# tagToEnum# addrToAny# anyToAddr# mkApUpd0#newBCO#unpackClosure# closureSize#getApStackVal# getCCSOf#getCurrentCCS# clearCCS# whereFrom# 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#isTrue#GHC.Prim.PtrEqreallyUnsafePtrEqualityunsafePtrEquality# sameArray#sameMutableArray#sameSmallArray#sameSmallMutableArray#sameByteArray#sameMutableByteArray# sameMutVar# sameTVar# sameMVar# sameIOPort#samePromptTag# eqStableName# unpackNBytes# breakpointbreakpointCondshiftL#shiftRL#iShiftL# iShiftRA# iShiftRL# GHC.Stack.CCScurrentCallStacknewArrayArray#unsafeFreezeArrayArray#sizeofArrayArray#sizeofMutableArrayArray#indexByteArrayArray#indexArrayArrayArray#readByteArrayArray#readMutableByteArrayArray#readArrayArrayArray#readMutableArrayArrayArray#writeByteArrayArray#writeMutableByteArrayArray#writeArrayArrayArray#writeMutableArrayArrayArray#copyArrayArray#copyMutableArrayArray#sameArrayArray#sameMutableArrayArray# traceEvent groupWithsortWith maxTupleSizetheatomicModifyMutVar#resizeSmallMutableArray# GHC.Prim.ExtgetThreadAllocationCounter# ghc-bignumGHC.Num.IntegerIntegerIOControl.Monad.IO.ClassliftIO GHC.MaybeMaybe Data.FoldablefoldlfoldrData.ByteStringcopyWord8Int8 GHC.ClassesOrd GHC.IO.UnsafeunsafePerformIOGHC.STSTversion getBinDir getLibDir getDynLibDir getDataDir getLibexecDirgetDataFileName getSysconfDir