!      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~                                       None"#&'12=?@ACFGMQSX`Z >protocol-buffersAThe Default class has the default-default values of types. See  Dhttp://code.google.com/apis/protocolbuffers/docs/proto.html#optional and also note that  types have a ? that is the first one in the .protot file (there is always at least one value). Instances of this for messages hold any default value defined in the .proto file. ? is where the  MessageAPI function getVal* looks when an optional field is not set.?protocol-buffersThe ?X is never undefined or an error to evalute. This makes it much more useful compared to  mergeEmpty=. In a default message all Optional field values are set to & and Repeated field values are empty.@protocol-buffersThe @ class is not a ,  mergeEmpty# is not a left or right unit like . The default AC is to take the second parameter and discard the first one. The B defaults to foldl associativity.NOTE:  mergeEmpty6 has been removed in protocol buffers version 2. Use ?h instead. New strict fields would mean that required fields in messages will be automatic errors with  mergeEmpty.Aprotocol-buffersA^ is the right-biased merge of two values. A message (or group) is merged recursively. Required field are always taken from the second message. Optional field values are taken from the most defined message or the second message if both are set. Repeated fields have the sequences concatenated. Note that strings and bytes are NOT concatenated.Bprotocol-buffersB is " F.foldl mergeAppend defaultValue d and this default definition is not overridden in any of the code except for the (Seq a) instance.Cprotocol-buffersCJ is the Int64 size type associated with the lazy bytestrings used in the Put and Get monads.Dprotocol-buffersDZ is the Int32 assoicated with a EnumValueDescriptorProto and is in the range 0 to 2^31-1.Gprotocol-buffersG is the integer associated with the FieldDescriptorProto's Type. The allowed range is currently 1 to 18, as shown below (excerpt from descritor.proto) / // 0 is reserved for errors. // Order is weird for historical reasons. TYPE_DOUBLE = 1; TYPE_FLOAT = 2; TYPE_INT64 = 3; // Not ZigZag encoded. Negative numbers // take 10 bytes. Use TYPE_SINT64 if negative // values are likely. TYPE_UINT64 = 4; TYPE_INT32 = 5; // Not ZigZag encoded. Negative numbers // take 10 bytes. Use TYPE_SINT32 if negative // values are likely. TYPE_FIXED64 = 6; TYPE_FIXED32 = 7; TYPE_BOOL = 8; TYPE_STRING = 9; TYPE_GROUP = 10; // Tag-delimited aggregate. TYPE_MESSAGE = 11; // Length-delimited aggregate. // New in version 2. TYPE_BYTES = 12; TYPE_UINT32 = 13; TYPE_ENUM = 14; TYPE_SFIXED32 = 15; TYPE_SFIXED64 = 16; TYPE_SINT32 = 17; // Uses ZigZag encoding. TYPE_SINT64 = 18; // Uses ZigZag encoding.Jprotocol-buffersJl is the 3 bit wire encoding value, and is currently in the range 0 to 5, leaving 6 and 7 currently invalid.0 Varint; : int32, int64, uint32, uint64, sint32, sint64, bool, enum1 64-bit : fixed64, sfixed64, double2 Length-delimited# : string, bytes, embedded messages3  Start group : groups (deprecated)4  End group : groups (deprecated)5 32-bit : fixed32, sfixed32, floatMprotocol-buffersM is the field number which can be in the range 1 to 2^29-1 but the value from 19000 to 19999 are forbidden (so sayeth Google).Pprotocol-buffersP7 is the 32 bit value with the upper 29 bits being the M and the lower 3 bits being the JSprotocol-buffersS is used to mark  \ values that (should) contain valid utf8 encoded strings. This type is used to represent  TYPE_STRING values.& 5>?@ABCDEFGHIJKLMNOPQRSTUVWXY&5ST PQRMNOJKLGHIDEFC@AB>?VWUXYNone"#&'12=?@ACFGMQSXprotocol-buffers? is supposed to allow the execution of the monad to be halted, awaiting more input. The computation is supposed to continue normally if this returns True, and is supposed to halt without calling suspend again if this returns False. All future calls to suspend will return False automatically and no nothing else.CThese semantics are too specialized to let this escape this module.protocol-buffers runs the todoK action and then rewinds only the BinaryParser state. Any new input from  or changes from b are kept. Changes to the user state (MonadState) are kept. The MonadWriter output is retained.XIf an error is thrown then the entire monad state is reset to last catchError as usual.protocol-buffers runs the todo action. If the action returns 0 then the BinaryParser state is rewound (as in ). If the action return K then the BinaryParser is not rewound, and lookAheadM acts as an identity.XIf an error is thrown then the entire monad state is reset to last catchError as usual.protocol-buffers runs the todo action. If the action returns 0 then the BinaryParser state is rewound (as in ). If the action return K then the BinaryParser is not rewound, and lookAheadE acts as an identity.XIf an error is thrown then the entire monad state is reset to last catchError as usual.protocol-buffers is the simple executorprotocol-buffersl is the simple executor, and will not ask for any continuation because this lazy bytestring is all the inputprotocol-buffers0Get the input currently available to the parser.protocol-buffers replaces the bytestream past the current # of read bytes. This will also affect pending MonadError handler and MonadPlus branches. I think all pending branches have to have fewer bytesRead than the current one. If this is wrong then an error will be thrown. WARNING :  is still untested.protocol-buffers Keep calling  until Nothing is passed to the Y continuation. This ensures all the data has been loaded into the state of the parser.protocol-buffers3Call suspend and throw and error with the provided msg$ if Nothing has been passed to the % continuation. Otherwise return ().protocol-bufferscheck that there are at least nM bytes available in the input. This will suspend if there is to little data.protocol-buffersPull n] bytes from the input, as a lazy ByteString. This will suspend if there is too little data.protocol-buffers causes the most recent catchError to be discarded, i.e. this reduces the stack of error handlers by removing the top one. These are the same handlers which Alternative(( |)) and MonadPlus(mplus) use. This is useful to commit to the current branch and let the garbage collector release the suspended handler and its hold on the earlier input.protocol-buffersDiscard the next m bytesprotocol-buffersReturn the number of & so far. Initially 0, never negative.protocol-buffersReturn the number of bytes ( before the current input runs out and  might be called.protocol-buffers#Return True if the number of bytes ? is 0. Any futher attempts to read an empty parser will call . which might result in more input to consume. Compare with protocol-bufferssReturn True if the input is exhausted and will never be added to. Returns False if there is input left to consume. Compare with protocol-buffersuget the longest prefix of the input where the high bit is set as well as following byte. This made getVarInt slower.protocol-buffersNget the longest prefix of the input where all the bytes satisfy the predicate.protocol-buffersPull n2 bytes from the input, as a strict ByteString. This will suspend if there is too little data. If the result spans multiple lazy chunks then the result occupies a freshly allocated strict bytestring, otherwise it fits in a single chunk and refers to the same immutable memory block as the whole chunk.protocol-buffersI use "splitAt" without tolerating too few bytes, so write a Maybe version. This is the only place I invoke L.Chunk as constructor instead of pattern matching. I claim that the first argument cannot be empty.&&None"#&'12=?@ACFGMQSXLprotocol-buffersThe  transformation has instances for several combiantions of input and output. These allow one to construct the Haskell types of MNameFMNamePMName and FNameFFName'PFName out of the protobuf types INameDINameLFIName. Currently, all the Haskell instances are for the String base type.protocol-buffersNThis is used to abstract over Utf8 and String. The important entry point is .protocol-buffers ensures the DIName isprotocol-buffers returns a list of non-empty a with all  characters removedprotocol-buffers@Parsed Haskell name ending with FName. Good constructor to use.protocol-buffers?Parsed Haskell name ending with MName. Good contructor to use.protocol-buffers-Full Haskell field name: MNames separated by , ending with a fieldprotocol-buffers.Full Haskell module name: MNames separated by , ending with a moduleprotocol-buffers&Fully qualified identifier: repeated ( then identifier)protocol-buffersW separated identifier which may or may start with a dot. There are never two or more 5s in a row. There is always at least one identifier.protocol-buffers"Contains one field name, non-emptyprotocol-buffers#Contains one module name, non-emptyprotocol-buffersContains one identifier nameprotocol-buffers examines the  and prepend a  if absent, promoting it to a .protocol-buffersTyped protocol-buffersTyped protocol-buffersTyped protocol-buffersjRight (True,_) means the input is a FIName. Right (False,_) means the input is a DIName (without leading )0This creates useful error messages for the user.protocol-buffersjRight (True,_) means the input is a FIName. Right (False,_) means the input is a DIName (without leading )0This creates useful error messages for the user.protocol-buffers'Return list of nonempty Utf8, with all  removedprotocol-buffers)Return list of nonempty String, with all  removedprotocol-buffersU is a set of strings which are Haskell keywords and should not be valid field names.I do not protect these values: "mdo","foreign","rec","proc" ( GHC manual section 8.3.16 ) because I do not anticipate using these extensions in the generated Haskell code.44None"#&'12=?@ACFGMQSXABCDEFABCDEFNone"#&'12=?@ACFGMQSXHprotocol-buffersThis is obtained via  on the stored  output of the {C in the module file. It is used in getting messages from the wire.Must not inspect argumentSprotocol-buffersGThe String is the Haskell name to write into the generated source files\protocol-buffers\ projects Double/Float to Rational or a special IEEE type. This is needed to track protobuf-2.3.0 which allows nan and inf and -inf default values.aprotocol-buffersa` stores the parsed default from the proto file in a form that will make a nice literal in the Language.Haskell.Exts.Syntax code generation by hprotoc.BNote that Utf8 labeled byte sequences have been stripped to just  0 here as this is sufficient for code generation.2On 25 August 2010 20:12, George van den Driessche  georgevdd@google.com} sent Chris Kuklewicz a patch to MakeReflections.parseDefEnum to ensure that HsDef'Enum holds the mangled form of the name.kprotocol-buffers4Used for writing and reading if packedTag is Nothinglprotocol-buffers0used for reading when Just {} instead of wireTagmprotocol-buffers.Bytes required in the Varint formatted wireTagpprotocol-buffers"True if repeated is the field typeqprotocol-buffers1True if packed would be valid for this field typerprotocol-buffers;fromEnum of Text.DescriptorProtos.FieldDescriptorProto.Typesprotocol-buffers!Set for Messages,Groups,and Enumstprotocol-bufferscrappy, but not escaped, thinguprotocol-buffersnice parsed thingwprotocol-buffersw> is used in getting messages from the wire. It supplies the J of precomposed wire tags that must be found in the message as well as a T of all allowed tags (including known extension fields and all required wire tags).KExtension fields not in the allowedTags set are still loaded, but only as  + blobs that will have to interpreted later.protocol-buffersAblank protobufName, maybe blank haskellPrefix and/or parentModuleprotocol-bufferspath to haskell moduleprotocol-buffers$filename without path of .proto fileprotocol-bufferstop level keysprotocol-buffersall messages and groupsprotocol-buffers all enumsprotocol-buffers9fully qualified name using "package" prefix (no mangling)protocol-buffers;Haskell specific prefix to module hierarchy (e.g. Text.Foo)protocol-buffers0.proto specified namespace (like Com.Google.Bar)protocol-buffersBThis is fully qualified name data type for code generation. The  was possibly specified on the hprotoc command line. The 1 is a combination of the module prefix from the '.proto'* file and any nested levels of definition.CThe name components are likely to have been mangled to ensure the & started with an uppercase letter, in  ['A'..'Z'] .protocol-buffers9fully qualified name using "package" prefix (no mangling)protocol-buffers;Haskell specific prefix to module hierarchy (e.g. Text.Foo)protocol-buffers0.proto specified namespace (like Com.Google.Bar)protocol-buffersM is used by the generated code to create a ProtoName with less newtype noise.Iprotocol-buffersMust not inspect argumentLprotocol-buffersMust not inspect argumentMprotocol-buffersMust not inspect argument\GIHJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~\{|}~ghijklmnopqrstuvabcdef\]^_`OPQRSTNGIHJKLMwxyzUVWXYZ[None"#&'12=>?@ACFGMQSX}protocol-buffers"Printable and readable field typesprotocol-buffersPrintable and readable messagesprotocol-buffers/This writes message as text-format protobuf to protocol-buffersqThis reads message as text-format protobuf from any Parsec-compatible source. Input must be completely consumed.  None"#&'12=?@ACFGMQSXM"protocol-buffersThe R class is for internal use, and may change. If there is a mis-match between the G and the type of b) then you will get a failure at runtime.8Users should stick to the message functions defined in  Text.ProtocolBuffers.WireMessage and exported to use user by Text.ProtocolBuffers#. These are less likely to change.protocol-buffersThis computes the size of the message's fields with tags on the wire with no initial tag or length (in bytes). This is also the length of the message as placed between group start and stop tags.protocol-buffers3This computes the size of the message fields as in  and add the length of the encoded size to the total. Thus this is the the length of the message including the encoded length header, but without any leading tag.protocol-buffersThis computes the size of the 9 and then adds the length an initial tag with the given M.protocol-buffersThis is 1 applied to . It result in a   with a length of  bytes.protocol-buffersThis is 1 applied to . It results in a   with a length of  bytes.protocol-buffersDThis writes just the message's fields with tags to the wire. This 34 monad can be composed and eventually executed with 1.This is actually  wirePut 10 msg protocol-bufferstThis writes the encoded length of the message's fields and then the message's fields with tags to the wire. This 36 monad can be composed and eventually executed with 1.This is actually  wirePut 11 msg protocol-buffers/This writes an encoded wire tag with the given Mt and then the encoded length of the message's fields and then the message's fields with tags to the wire. This 36 monad can be composed and eventually executed with 1.protocol-buffersThis consumes the  ' to decode a message. It assumes the   is merely a sequence of the tagged fields of the message, and consumes until a group stop tag is detected or the entire input is consumed. Any  3 past the end of the stop tag is returned as well.This is  applied to .protocol-buffersThis  applied to .This first reads the encoded length of the message and will then succeed when it has consumed precisely this many additional bytes. The  # after this point will be returned.protocol-buffersXThis reads the tagged message fields until the stop tag or the end of input is reached.This is actually  wireGet 10 msg protocol-buffers;This reads the encoded message length and then the message.This is actually  wireGet 11 msg protocol-buffers'This reads a wire tag (must be of type '2' ) to get the MW. Then the encoded message length is read, followed by the message itself. Both the M and the message are returned.3This allows for incremental reading and processing.protocol-buffersThis is  with the  results converted to  calls and the trailing  O discarded. This use of runtime errors is discouraged, but may be convenient.protocol-buffers This is like V, without the ability to pass in more input beyond the initial ByteString. Thus the  l argument is taken to be the entire input. To be able to incrementally feed in more input you should use  and respond to  differently.protocol-buffersUsed in generated code.protocol-buffersUsed in generated code.protocol-buffersUsed in generated code.protocol-buffersUsed in generated code.protocol-buffersUsed in generated code.protocol-buffersUsed in generated code.protocol-buffersUsed in generated code.protocol-buffersUsed in generated code. protocol-buffersUsed in generated code. protocol-buffersUsed in generated code. protocol-buffersUsed in generated code. protocol-buffersUsed in generated code. protocol-buffersUsed in generated code.protocol-buffersUsed in generated code.protocol-buffersUsed in generated code.protocol-buffersWUsed by generated code getBareMessageWith assumes the wireTag for the message, if it existed, has already been read. getBareMessageWith assumes that it does needs to read the Varint encoded length of the message. getBareMessageWith will consume the entire ByteString it is operating on, or until it finds any STOP_GROUP tag (wireType == 4)*protocol-buffers]This reads in the raw bytestring corresponding to an field known only through the wiretag's M and J.protocol-buffers'After a group start tag with the given MO this will skip ahead in the stream past the end tag of that group. Used by *K to help compule the length of an unknown field when loading an extension.G/0123      !"#$%&'()*+G3210"#+)(/      !*%$'& None"#&'12=?@ACFGMQSXX8protocol-buffersThis is a suposedly opaque type:protocol-bufferskMessages that can store unknown fields implement this interface. UnknownField is a supposedly opaque type.=protocol-buffers"This is used by the generated code>protocol-buffers"This is used by the generated code?protocol-buffers"This is used by the generated code@protocol-buffersEThis is used by the generated code. Here for backwards compatibility.Bprotocol-buffers"This is used by the generated codeCprotocol-buffers"This is used by the generated code6789:;<=>?@ABC89:;<67=>?@ABC None"#&'12=?@ACFGMQSXQprotocol-buffersvAccess data in a message. The first argument is always the message. The second argument can be one of 4 categories.YThe field name of a required field acts a simple retrieval of the data from the message.vThe field name of an optional field will retreive the data if it is set or lookup the default value if it is not set.JThe field name of a repeated field always retrieves the (possibly empty) 5 of values.A Key for an optional or repeated value will act as the field name does above, but if there is a type mismatch or parse error it will use the defaultValue for optional types and an empty sequence for repeated types.Rprotocol-buffers-Check whether data is present in the message.Required fields always return .2Optional fields return whether a value is present.Repeated field return 0 if there are no values, otherwise they return .Keys return as optional or repeated, but checks only if the field # is present. This assumes that there are no collisions where more that one key refers to the same field number of this message type.Sprotocol-buffersThe i and  GPWitness GADTs use S" as a shorthand for many classes.Tprotocol-buffersThe T1 class has three functions for user of the API: U, V, and W. The X is used in generated code.'There are two instances of this class, " for optional message fields and 5o for repeated message fields. This class allows for uniform treatment of these two kinds of extension fields.Uprotocol-buffers:Change or clear the value of a key in a message. Passing " with an optional key or an empty 5w with a repeated key clears the value. This function thus maintains the invariant that having a field number in the ]0 map means that the field is set and not empty.AThis should be only way to set the contents of a extension field.Vprotocol-buffers3Access the key in the message. Optional have type (Key Maybe msg v) and return type  (Maybe v)" while repeated fields have type (Key Seq msg v) and return type (Seq v).=There are a few sources of errors with the lookup of the key:5It may find unparsed bytes from loading the message. Vj will attempt to parse the bytes as the key's value type, and may fail. The parsing is done with the  parseWireExt. method (which is not exported to user API).<The wrong optional-key versus repeated-key type is a failure9The wrong type of the value might be found in the map andcause a failureaThe failures above should only happen if two different keys are used with the same field number.Yprotocol-buffersY9 abstracts the operations of storing and retrieving the ]W from the message, and provides the reflection needed to know the valid field numbers.This only used internally.]protocol-buffers|ExtField is a newtype'd map from the numeric FieldId key to the ExtFieldValue. This allows for the needed class instances.protocol-buffers'For making a Data instance for ExtFieldaprotocol-bufferskThe WireType is used to ensure the Seq is homogeneous. The ByteString is the unparsed input after the tag.fprotocol-buffersThe f} is needed to distinguish the packed repeated format from the repeated format. This is only used in the phantom type of Key.protocol-buffersThe  is another specialization of Dynamic and is used in d for repeated fields.protocol-buffersThe  is my specialization of Dynamic<. It hides the type with an existential. This is used in c for optional fields.iprotocol-buffersThe i data type is used with the TA class to put, get, and clear external fields of messages. The i can also be used with the  MessagesAPIW to get a possibly default value and to check whether a key has been set in a message.The i type (opaque to the user) has a phantom type of Maybe or Seq that corresponds to Optional or Repeated fields. And a second phantom type that matches the message type it must be used with. The third type parameter corresponds to the Haskell value type.The i\ is a GADT that puts all the needed class instances into scope. The actual content is the M ( numeric key), the G (for sanity checks), and Maybe v! (a non-standard default value).When code is generated all of the known keys are taken into account in the deserialization from the wire. Unknown extension fields are read as a collection of raw byte sequences. If a key is then presented it will be used to parse the bytes.There is no guarantee for what happens if two Keys disagree about the type of a field; in particular there may be undefined values and runtime errors. The data constructor for iO has to be exported to the generated code, but is not exposed to the user by Text.ProtocolBuffers.kprotocol-buffers=This allows reflection, in this case it gives the numerical MA of the key, from 1 to 2^29-1 (excluding 19,000 through 19,999).lprotocol-buffers2This allows reflection, in this case it gives the G& enumeration value (1 to 18) of the /Text.DescriptorProtos.FieldDescriptorProto.Type of the field.mprotocol-buffers/This will return the default value for a given i, which is set in the '.proto' file, or if unset it is the ? of that type.protocol-buffers1Used only in gfoldl for Data instance of ExtFieldprotocol-buffers=Used only in gfoldl and gunfold for Data instance of ExtFieldprotocol-buffers=Used only in gfoldl and gunfold for Data instance of ExtFieldprotocol-buffers=Used only in gfoldl and gunfold for Data instance of ExtFieldnprotocol-bufferscwireKeyToUnPacked is used to load a repeated packed format into a repeated non-packed extension keyoprotocol-buffers_wireKeyToPacked is used to load a repeated unpacked format into a repeated packed extension keyprotocol-buffersused by Q and X for the  instanceprotocol-buffers is an intermediate handler between parseWireExt* and applyGet. This does not know whether the EP will result in a single r or repeat r, so it always returns a Seq. It may also realize that there is a mismatch between the desired FieldType and the WireTypeprotocol-buffersConverts the the  into an * type and enforces consumption of entire   . Used by  and 7 to process raw wire input that has been stored in an ].protocol-buffersused by Q and X for the 5 instancepprotocol-buffers"This is used by the generated codeqprotocol-buffers`This is used by the generated code. The data is serialized in order of increasing field number.rprotocol-buffers"This is used by the generated codetprotocol-buffersget a value from the wire into the message's ExtField. This is used by generated code for extensions that were not known at compile time.%PQRSTVUWXYZ[\]^_`abcdefghijklmnopqrst%klmijTVUWXPQRfgh_`pqrtsnoS]^YZ[\abcdeNone"#&'12=?@ACFGMQSX*)('&%$#"!   +,-.0456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYABCDEFGIHJKLMOPQRSTwx{      !#8:;<=>?@ABCPQRSTXYZ[\]fijnopqrst4-.,6798<;:=+ *)('&%$#"! PQRSTXYZ[\]fijnopqrstGIHJKLMOPQRSTwx{8:;<=>?@ABC0      !# None"#&'12=?@ACFGMQSXP135>?@ABCDGJMPSTUVWABCDEFGIHJKLMNOPQRSTabcdefghijklmnopqrstuv{|}~PQRTVUWiklmx5>?@ABCDGJMPSTUVWPQRTVUWiklmGIHJKLMNOPQRSTabcdefghijklmnopqrstuv{|}~13       ! " # $ %&'&(&)&*&+&,&-./..0.1.2.3.4 5 6 7 8 9 : ; < = > ? @ A B CD EF GH IJKLMKLNKLOKLPKLQRSTUVTWXTWYZ[\Z[]^_`^ab^ac^defghijkllmnnoppqrrsttuvvwxyz{|}~         !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghhijklmmnopqrstuvwxyz{|}~~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEF G H I I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m m n n o p q r s t t u v v w x y z { | } ~                                                    I I    I  TW              .protocol-buffers-2.4.13-ETwVbTjzrOOHMS8beaMM2WText.ProtocolBuffers.HeaderText.ProtocolBuffers.Basic Text.ProtocolBuffers.WireMessageText.ProtocolBuffers.Get Text.ProtocolBuffers.IdentifiersText.ProtocolBuffers.ProtoJSON Text.ProtocolBuffers.Reflections Text.ProtocolBuffers.TextMessageText.ProtocolBuffers.UnknownText.ProtocolBuffers.ExtensionsText.ProtocolBuffersbase Data.DataDataghc-prim GHC.TypesBoolDoubleFloatGHC.IntInt32Int64 GHC.MaybeMaybeGHC.WordWord32Word64bytestring-0.10.8.2Data.ByteString.Lazy.Internal ByteString$aeson-1.4.6.0-1XnxcetEtfUG8O3EDchcasData.Aeson.Types.ToJSONtoEncodingList toJSONList toEncodingtoJSONToJSONData.Aeson.Types.FromJSONexplicitParseFieldMaybeexplicitParseFieldwithText withObject parseJSONList parseJSONFromJSONData.Aeson.Types.InternalNullNumberStringArrayObjectValuegmapMogmapMpgmapMgmapQigmapQgmapQrgmapQlgmapT dataCast2 dataCast1 dataTypeOftoConstrgunfoldgfoldl Control.Monad<=< Data.Foldablemsum Data.Maybe fromMaybeGHC.Baseapbinary-0.8.6.0Data.Binary.PutputLazyByteStringrunPutMrunPutPutMPutData.ByteString.Lazy.Char8packcontainers-0.6.0.1Data.Sequence.InternalSeqData.Set.InternalfromDistinctAscListmember mtl-2.2.2Control.Monad.Error.Class catchError throwErrorparsec-3.1.13.0Text.Parsec.CharspacesText.Parsec.CombinatorsepEndBychoiceText.Parsec.PrimtryDefault defaultValue Mergeable mergeAppend mergeConcatWireSizeEnumCode getEnumCode FieldType getFieldTypeWireType getWireTypeFieldId getFieldIdWireTag getWireTagUtf8utf8 isValidUTF8toUtf8 uToString uFromString$fFromJSONUtf8 $fToJSONUtf8 $fMonoidUtf8$fSemigroupUtf8$fIsStringUtf8 $fShowUtf8 $fReadUtf8$fBoundedFieldId$fBoundedWireType$fBoundedFieldType$fBoundedEnumCode $fDefaultUtf8$fDefaultByteString $fDefaultSeq$fDefaultMaybe $fDefaultBool$fDefaultDouble$fDefaultFloat$fDefaultInt32$fDefaultInt64$fDefaultWord32$fDefaultWord64$fMergeableWord64$fMergeableWord32$fMergeableInt64$fMergeableInt32$fMergeableFloat$fMergeableDouble$fMergeableByteString$fMergeableUtf8$fMergeableBool$fMergeableSeq$fMergeableMaybe $fDataUtf8$fEqUtf8 $fOrdUtf8 $fEqWireTag $fOrdWireTag $fEnumWireTag $fReadWireTag $fShowWireTag $fNumWireTag $fBitsWireTag$fBoundedWireTag $fDataWireTag $fEqFieldId $fOrdFieldId $fEnumFieldId $fReadFieldId $fShowFieldId $fNumFieldId $fDataFieldId $fIxFieldId $fEqWireType $fOrdWireType$fEnumWireType$fReadWireType$fShowWireType $fNumWireType$fDataWireType $fEqFieldType$fOrdFieldType$fEnumFieldType$fReadFieldType$fShowFieldType$fNumFieldType$fDataFieldType $fEqEnumCode $fOrdEnumCode$fReadEnumCode$fShowEnumCode $fNumEnumCode$fDataEnumCodeGetResultFailedFinishedPartialdecode7unrolleddecode7 decode7size lookAhead lookAheadM lookAheadErunGet runGetAll getAvailable putAvailablesuspendUntilComplete ensureBytesgetLazyByteStringskip bytesRead remainingisEmpty isReallyEmpty highBitRunspanOf getByteString getWordhostgetWord8 getWord16be getWord16le getWord16host getWord32be getWord32le getWord32host getWord64be getWord64le getWord64host getStorable $fShowResult$fShowFrameStack$fAlternativeGet$fApplicativeGet$fMonadPlusGet$fMonadError[]Get$fMonadFailGet $fMonadGet $fFunctorGet$fMonadSuspendGet$fShowSManglemangleDottedunconsconsdotvalidIvalidDIsplitPFNamePMNameFFNameffNameFMNamefmNameFINamefiNameDINamediNameFNamefNameMNamemNameINameiNameunulltoString fromStringjoinPMjoinPFdifisplitDIsplitFIsplitFM promoteDI promoteFI promoteFM promoteFFdotFMdotFFfqAppend checkDIString checkDIUtf8 $fShowIName $fReadIName $fShowMName $fReadMName $fShowFName $fReadFName $fShowDIName $fReadDIName $fShowFIName $fReadFIName $fShowFMName $fReadFMName $fShowFFName $fReadFFName $fDotted[] $fDottedUtf8$fMangleFINamePFName$fMangleDINamePFName$fMangleFINamePMName$fMangleDINamePMName$fMangleMNameFName$fMangleINameFName$fMangleINameFName0$fMangleFNameMName$fMangleINameMName$fMangleINameMName0 $fDataIName $fEqIName $fOrdIName $fDataMName $fEqMName $fOrdMName $fDataFName $fEqFName $fOrdFName $fDataDIName $fEqDIName $fOrdDIName $fDataFIName $fEqFIName $fOrdFIName $fDataFMName $fEqFMName $fOrdFMName $fDataFFName $fEqFFName $fOrdFFName $fShowPMName $fDataPMName $fReadPMName $fEqPMName $fOrdPMName $fShowPFName $fDataPFName $fReadPFName $fEqPFName $fOrdPFName objectNoEmptytoJSONShowWithPayloadparseJSONReadWithPayload parseJSONBooltoJSONByteStringparseJSONByteStringReflectDescriptorgetMessageInforeflectDescriptorInfo ReflectEnum reflectEnumreflectEnumInfo parentOfEnum EnumInfoAppEnumInfoenumName enumFilePath enumValuesenumJsonInstances OneofInfo oneofName oneofFName oneofFilePath oneofFieldsoneofMakeLenses SomeRealFloat SRF'RationalSRF'nanSRF'ninfSRF'inf HsDefault HsDef'BoolHsDef'ByteStringHsDef'RealFloat HsDef'Integer HsDef'Enum FieldInfo fieldName fieldNumberwireTag packedTag wireTagLengthisPacked isRequired canRepeat mightPacktypeCodetypeName hsRawDefault hsDefaultKeyInfoGetMessageInfo requiredTags allowedTagsDescriptorInfodescName descFilePathisGroupfields descOneofskeys extRanges knownKeys storeUnknown lazyFields makeLenses jsonInstances ProtoInfoprotoMod protoFilePath protoSource extensionKeysmessagesenumsoneofs knownKeyMap ProtoFName protobufName'haskellPrefix' parentModule' baseName'baseNamePrefix' ProtoName protobufName haskellPrefix parentModulebaseNamemakePNFtoRFfromRF$fShowProtoName$fReadProtoName $fEqProtoName$fOrdProtoName$fDataProtoName$fShowProtoFName$fReadProtoFName$fEqProtoFName$fOrdProtoFName$fDataProtoFName$fShowGetMessageInfo$fReadGetMessageInfo$fEqGetMessageInfo$fOrdGetMessageInfo$fDataGetMessageInfo$fShowSomeRealFloat$fReadSomeRealFloat$fEqSomeRealFloat$fOrdSomeRealFloat$fDataSomeRealFloat$fShowHsDefault$fReadHsDefault $fEqHsDefault$fOrdHsDefault$fDataHsDefault$fShowFieldInfo$fReadFieldInfo $fEqFieldInfo$fOrdFieldInfo$fDataFieldInfo$fShowOneofInfo$fReadOneofInfo $fEqOneofInfo$fOrdOneofInfo$fDataOneofInfo$fShowDescriptorInfo$fReadDescriptorInfo$fEqDescriptorInfo$fOrdDescriptorInfo$fDataDescriptorInfo$fShowEnumInfo$fReadEnumInfo $fEqEnumInfo $fOrdEnumInfo$fDataEnumInfo$fShowProtoInfo$fReadProtoInfo $fEqProtoInfo$fOrdProtoInfo$fDataProtoInfoTextTypetellTgetTTextMsgtextPuttextGettellShowtellSubMessagemessagePutTextgetRead getSubMessagemessageGetText $fTextTypeSeq$fTextTypeMaybe$fTextTypeByteString$fTextTypeUtf8$fTextTypeFloat$fTextTypeDouble$fTextTypeBool$fTextTypeWord64$fTextTypeWord32$fTextTypeInt64$fTextTypeInt32WirewireSizewirePutwirePutWithSizewireGet wireGetPacked messageSizemessageWithLengthSizemessageAsFieldSize messagePutmessageWithLengthPut messagePutMmessageWithLengthPutMmessageAsFieldPutM messageGetmessageWithLengthGet messageGetMmessageWithLengthGetMmessageAsFieldGetM getFromBS runGetOnLazyprependMessageSizesequencePutWithSizewirePutReqWithSizewirePutOptWithSizewirePutRepWithSizewirePutPackedWithSize wirePutReq wirePutOpt wirePutRep wirePutPacked wireSizeReq wireSizeOpt wireSizeRepwireSizePackedputSizetoPackedWireTag toWireTag mkWireTag splitWireTag fieldIdOfwireGetPackedEnumgetMessageWithgetBareMessageWith unknownFieldunknowncastWord32ToFloatcastFloatToWord32castWord64ToDoublecastDoubleToWord64 wireSizeErr wirePutErr wireGetErr wireGetEnum size'WireTag size'WireSize zzEncode32 zzEncode64 zzDecode32 zzDecode64 getVarInt putVarUIntwireGetFromWire toWireType $fWireInt$fWireByteString $fWireUtf8 $fWireBool $fWireWord32 $fWireWord64 $fWireInt32 $fWireInt64 $fWireFloat $fWireDoubleUnknownFieldValueUFV UnknownFieldUnknownMessagegetUnknownFieldputUnknownFieldwireSizeUnknownFieldwirePutUnknownFieldwirePutUnknownFieldWithSize catch'Unknowncatch'Unknown' loadUnknowndiscardUnknown$fDefaultUnknownField$fMergeableUnknownField$fEqUnknownFieldValue$fOrdUnknownFieldValue$fShowUnknownFieldValue$fReadUnknownFieldValue$fDataUnknownFieldValue$fEqUnknownField$fOrdUnknownField$fShowUnknownField$fReadUnknownField$fDataUnknownField MessageAPIgetValisSetGPBExtKeyputExtgetExtclearExt wireGetKey ExtendMessage getExtField putExtFieldvalidExtRangesExtFieldEP ExtFieldValue ExtFromWire ExtOptional ExtRepeated ExtPacked PackedSeq unPackedSeqKey getKeyFieldIdgetKeyFieldTypegetKeyDefaultValuewireGetKeyToUnPackedwireGetKeyToPackedwireSizeExtFieldwirePutExtFieldwirePutExtFieldWithSize notExtension loadExtension $fGPBWord64 $fGPBWord32 $fGPBInt64 $fGPBInt32 $fGPBFloat $fGPBDouble $fGPBUtf8$fGPBByteString $fGPBBool$fShowGPDynSeq $fOrdGPDynSeq $fEqGPDynSeq $fShowGPDyn $fOrdGPDyn $fEqGPDyn$fDefaultExtField$fMergeableExtField$fDataExtField$fExtendMessageDummyMessageType$fExtKeyPackedSeq $fExtKeySeq $fExtKeyMaybe$fEqExtFieldValue $fShowKey$fMessageAPImsg->Word64$fMessageAPImsg->Word32$fMessageAPImsg->Int64$fMessageAPImsg->Int32$fMessageAPImsg->Float$fMessageAPImsg->Double$fMessageAPImsg->Utf8$fMessageAPImsg->ByteString$fMessageAPImsgKeySeq$fMessageAPImsgKeyv$fMessageAPImsg->Seq$fMessageAPImsg->a$fDataEP$fEqEP$fOrdEP$fShowEP$fDataExtDataPair$fShowExtDataPair$fOrdExtFieldValue$fShowExtFieldValue $fEqExtField $fOrdExtField$fShowExtFieldappendemptyBSGHC.EnumEnumNothingMonoidmempty MonadSuspendsuspendJust Data.EitherLeftRight suspendMsgdiscardInnerHandler splitAtOrDie. splitUtf8 splitStringreserved Text.ReadreadGHC.ShowshowSet Text.Read.LexLexemeGHC.Errerror skipGroupTrueFalse ExtDataPairGPDynSeqGPDyn dataToList dataFromList ty_ExtField con_ExtFieldparseWireExtMaybe chooseGetapplyGetEitherparseWireExtSeq