proto-lens-protoc 0.5.0.0 → 0.6.0.0

raw patch · 20 files changed

+15045/−3229 lines, 20 filesdep +ghcdep +ghc-pathsdep +ghc-source-gendep −haskell-src-extsdep ~basedep ~lens-familydep ~proto-lensPVP ok

version bump matches the API change (PVP)

Dependencies added: ghc, ghc-paths, ghc-source-gen, proto-lens-runtime

Dependencies removed: haskell-src-exts

Dependency ranges changed: base, lens-family, proto-lens

API changes (from Hackage documentation)

Files

• Changelog.md +18/−0
• app/Data/ProtoLens/Compiler/Definitions.hs +631/−0
• app/Data/ProtoLens/Compiler/Generate.hs +1054/−0
• app/Data/ProtoLens/Compiler/Generate/Commented.hs +48/−0
• app/Data/ProtoLens/Compiler/Generate/Encoding.hs +638/−0
• app/Data/ProtoLens/Compiler/Generate/Field.hs +261/−0
• app/Data/ProtoLens/Compiler/Plugin.hs +105/−0
• app/Proto/Google/Protobuf/Compiler/Plugin.hs +1039/−0
• app/Proto/Google/Protobuf/Compiler/Plugin_Fields.hs +181/−0
• app/Proto/Google/Protobuf/Descriptor.hs +9947/−0
• app/Proto/Google/Protobuf/Descriptor_Fields.hs +1039/−0
• app/protoc-gen-haskell.hs +36/−40
• proto-lens-protoc.cabal +24/−19
• src/Data/ProtoLens/Compiler/Combinators.hs +0/−462
• src/Data/ProtoLens/Compiler/Definitions.hs +0/−650
• src/Data/ProtoLens/Compiler/Generate.hs +0/−1030
• src/Data/ProtoLens/Compiler/Generate/Encoding.hs +0/−638
• src/Data/ProtoLens/Compiler/Generate/Field.hs +0/−260
• src/Data/ProtoLens/Compiler/ModuleName.hs +24/−0
• src/Data/ProtoLens/Compiler/Plugin.hs +0/−130

@@ -1,5 +1,23 @@ # Changelog for `proto-lens-protoc` +## v0.6.0.0++### Breaking Changes+- Reexport transitive definitions from modules generated for `.proto` files+  with `import public` statements (#329).+- Bump lower bounds to base-4.10 (ghc-8.2).+- Use `ghc-source-gen` instead of `haskell-src-exts`.  Removes+  `Data.ProtoLens.Compiler.Combinators` and adds+  `Data.ProtoLens.Compiler.Definitions`.+- Limit the exposed library to a single module+  `Data.ProtoLens.Compiler.ModuleName`.  The other modules were not+  used in practice, and exposed internals unnecessarily.++### Backwards-Compatible Changes+- Fix a potential naming conflict when message types and enum values+  are the same except for case.+- Support dependencies on base-4.13 (ghc-8.8) and lens-family-2.0.+ ## v0.5.0.0  ### Breaking Changes

@@ -0,0 +1,631 @@+-- Copyright 2016 Google Inc. All Rights Reserved.+--+-- Use of this source code is governed by a BSD-style+-- license that can be found in the LICENSE file or at+-- https://developers.google.com/open-source/licenses/bsd++-- | This module takes care of collecting all the definitions in a .proto file+-- and assigning Haskell names to all of the defined things (messages, enums+-- and field names).+{-# LANGUAGE CPP #-}+{-# LANGUAGE DeriveFunctor #-}+{-# LANGUAGE GeneralizedNewtypeDeriving #-}+{-# LANGUAGE OverloadedLabels #-}+{-# LANGUAGE OverloadedStrings #-}+module Data.ProtoLens.Compiler.Definitions+    ( Env+    , Definition(..)+    , MessageInfo(..)+    , ServiceInfo(..)+    , MethodInfo(..)+    , PlainFieldInfo(..)+    , FieldInfo(..)+    , FieldKind(..)+    , FieldPacking(..)+    , MapEntryInfo(..)+    , OneofInfo(..)+    , OneofCase(..)+    , FieldName(..)+    , Symbol+    , nameFromSymbol+    , promoteSymbol+    , EnumInfo(..)+    , EnumValueInfo(..)+    , EnumUnrecognizedInfo(..)+    , qualifyEnv+    , unqualifyEnv+    , collectDefinitions+    , collectServices+    , definedFieldType+    , definedType+    , camelCase+    , overloadedFieldName+    ) where++import Control.Applicative (liftA2)+import Data.Char (isUpper, toUpper)+import Data.Int (Int32)+import Data.List (mapAccumL)+import qualified Data.Map as Map+import Data.Maybe (fromMaybe)+#if !MIN_VERSION_base(4,11,0)+import Data.Monoid ((<>))+#endif+import Data.ProtoLens.Labels ()+import qualified Data.Semigroup as Semigroup+import qualified Data.Set as Set+import Data.String (IsString(..))+import Data.Text (Text, cons, splitOn, toLower, uncons, unpack)+import qualified Data.Text as T+import Data.Tree+    ( Tree(..)+    , Forest+    , flatten+    )+import Lens.Family2 ((^.), (^..), toListOf)+import Proto.Google.Protobuf.Descriptor+    ( DescriptorProto+    , EnumDescriptorProto+    , EnumValueDescriptorProto+    , FieldDescriptorProto+    , FieldDescriptorProto'Label(..)+    , FieldDescriptorProto'Type(..)+    , FileDescriptorProto+    , MethodDescriptorProto+    , ServiceDescriptorProto+    )+import GHC.SourceGen+    ( OccNameStr+    , RdrNameStr+    , ModuleNameStr+    , HsType'+    , qual+    , stringTy+    , unqual+    )++-- | 'Env' contains a mapping of proto names (as specified in the .proto file)+-- to Haskell names.  The keys are fully-qualified names, for example,+-- ".package.Message.Submessage".  (The protocol_compiler tool emits all+-- message field types in this form, even if they refer to local definitions.)+--+-- The type 'n' can be either a 'Name' (when talking about definitions within+-- the current file) or a (qualified) 'RdrNameStr' (when talking about definitions+-- either from this or another file).+type Env n = Map.Map Text (Definition n)++data SyntaxType = Proto2 | Proto3+    deriving (Show, Eq)++fileSyntaxType :: FileDescriptorProto -> SyntaxType+fileSyntaxType f = case f ^. #syntax of+    "proto2" -> Proto2+    "proto3" -> Proto3+    "" -> Proto2  -- The proto compiler doesn't set syntax for proto2 files.+    s -> error $ "Unknown syntax type " ++ show s++data Definition n = Message (MessageInfo n) | Enum (EnumInfo n)+    deriving Functor++-- | All the information needed to define or use a proto message type.+data MessageInfo n = MessageInfo+    { messageName :: n  -- ^ Haskell type name+    , messageConstructorName :: n  -- ^ Haskell constructor name+    , messageDescriptor :: DescriptorProto+    , messageFields :: [PlainFieldInfo] -- ^ Fields not belonging to a oneof.+    , messageOneofFields :: [OneofInfo]+      -- ^ The oneofs in this message, associated with the fields that+      --   belong to them.+    , messageUnknownFields :: OccNameStr+      -- ^ The name of the Haskell field in this message that holds the+      -- unknown fields.+    , groupFieldNumber :: Maybe Int32+      -- ^ The number of the field that holds this message, if it is a group.+    } deriving Functor++data ServiceInfo = ServiceInfo+    { serviceName    :: Text+    , servicePackage :: Text+    , serviceMethods :: [MethodInfo]+    }++data MethodInfo = MethodInfo+    { methodName   :: Text+    , methodIdent  :: Text+    , methodInput  :: Text+    , methodOutput :: Text+    , methodClientStreaming :: Bool+    , methodServerStreaming :: Bool+    }++-- | Information about a single field of a proto message,+-- associated with how it is stored.+data PlainFieldInfo = PlainFieldInfo+    { plainFieldKind :: FieldKind+    , plainFieldInfo :: FieldInfo+    }++-- | Information about a single field of a proto message.+data FieldInfo = FieldInfo+    { fieldDescriptor  :: FieldDescriptorProto+    , fieldName :: FieldName+    }++-- | How a field is stored inside of the proto message.+data FieldKind+    = RequiredField+        -- ^ A proto2 required field.  Stored internally as a value.+    | OptionalValueField+        -- ^ A proto3 optional scalar field.  Stored internally as a+        -- value, and defaults to corresponding instance of fieldDefault.+    | OptionalMaybeField+        -- ^ An optional field where the "unset" and "defaulT" values+        -- are distinguishable.  Stored internally as a Maybe.+        -- In particular: proto2 optional fields, proto3 messages,+        -- and "oneof" fields.+    | RepeatedField FieldPacking+        -- ^ A field containing a sequence of values.+        -- Stored internally as either a list or a map, depending on+        -- whether the field's FieldDescriptorProto of the field has+        -- options.map_entry set.+    | MapField MapEntryInfo+       -- ^ A field containing a map of keys to values.+       -- Serialized as a repeated field of an autogenerated "entry"+       -- proto type, each instance of which contains a key-value pair.++data FieldPacking+    = NotPackable  -- ^ Cannot be packed (e.g., strings or messages).+    | Packable     -- ^ Can be decoded as packed, but should not be not be+                   --   encoded as packed by default.+    | Packed       -- ^ Can be decoded as packed, and should be encoded+                   --   as packed by default.+  deriving Eq++data OneofInfo = OneofInfo+    { oneofFieldName :: FieldName+    , oneofTypeName :: OccNameStr+      -- ^ The name of the sum type corresponding to this oneof.+    , oneofCases :: [OneofCase]+      -- ^ The individual fields that make up this oneof.+    }++data OneofCase = OneofCase+    { caseField :: FieldInfo+    , caseConstructorName :: OccNameStr+        -- ^ The constructor for building a 'oneofTypeName' from the+        -- value in this field.+    , casePrismName :: OccNameStr+        -- ^ The name for building 'Prism' definition.+    }++-- | The "entry" type for a map field is a proto message, autogenerated by+-- protoc, that has two fields: a key and a value. The map field should be+-- serialized like a repeated field of the entry messages.+data MapEntryInfo = MapEntryInfo+    { mapEntryTypeName :: OccNameStr+        -- ^ The Haskell name for this type.+    , keyField :: FieldInfo+        -- ^ The field of the entry type corresponding to the map key.+    , valueField :: FieldInfo+        -- ^ The field of the entry type corresponding to the map value.+    }++data FieldName = FieldName+    { overloadedName :: Symbol+      -- ^ The overloaded name of lenses that access this field.+      -- For example, if the field is called "foo_bar" in the .proto+      -- then @overloadedName == "fooBar"@ and we might generate+      -- @fooBar@ and/or @maybe'fooBar@ lenses to access the data.+      --+      -- May be shared between two different message data types in the same+      -- module.+    , haskellRecordFieldName :: OccNameStr+      -- ^ The Haskell name of this internal record field; for example,+      -- "_Foo'Bar'baz.  Unique within each module.+    }++-- | A string that refers to the name (in Haskell) of a lens that accesses a+-- field.+--+-- For example, in the signature of the overloaded lens+--+-- @+--     foo :: HasLens "foo" ... => Lens ...+-- @+--+-- a 'Symbol' is used to construct both the type-level argument to+-- @HasLens@ and the name of the function @foo@.+newtype Symbol = Symbol String+    deriving (Eq, Ord, IsString, Semigroup.Semigroup, Monoid)++nameFromSymbol :: Symbol -> OccNameStr+nameFromSymbol (Symbol s) = fromString s++-- | Construct a promoted, type-level string.+promoteSymbol :: Symbol -> HsType'+promoteSymbol (Symbol s) = stringTy s++-- | All the information needed to define or use a proto enum type.+data EnumInfo n = EnumInfo+    { enumName :: n+    , enumUnrecognized :: Maybe EnumUnrecognizedInfo+    , enumDescriptor :: EnumDescriptorProto+    , enumValues :: [EnumValueInfo n]+    } deriving Functor++-- | Information about the "unrecognized" case of an enum.+data EnumUnrecognizedInfo = EnumUnrecognizedInfo+    { unrecognizedName :: OccNameStr+    , unrecognizedValueName :: OccNameStr+    }++-- | Information about a single value case of a proto enum.+data EnumValueInfo n = EnumValueInfo+    { enumValueName :: n+    , enumValueDescriptor :: EnumValueDescriptorProto+    , enumAliasOf :: Maybe OccNameStr+        -- ^ If 'Nothing', we turn value into a normal constructor of the enum.+        -- If @'Just' n@, we're treating it as an alias of the constructor @n@+        -- (a PatternSynonym in Haskell).  This mirrors the behavior of the+        -- Java API.+    } deriving Functor++mapEnv :: (n -> n') -> Env n -> Env n'+mapEnv f = fmap $ fmap f++-- Lift a set of local definitions into references to a specific module.+qualifyEnv :: ModuleNameStr -> Env OccNameStr -> Env RdrNameStr+qualifyEnv m = mapEnv (qual m)++-- Lift a set of local definitions into references to the current module.+unqualifyEnv :: Env OccNameStr -> Env RdrNameStr+unqualifyEnv = mapEnv unqual++-- | Look up the Haskell name for the type of a given field (message or enum).+definedFieldType :: FieldDescriptorProto -> Env RdrNameStr -> Definition RdrNameStr+definedFieldType fd env = fromMaybe err $ Map.lookup (fd ^. #typeName) env+  where+    err = error $ "definedFieldType: Field type " ++ unpack (fd ^. #typeName)+                  ++ " not found in environment."++-- | Look up the Haskell name for the type of a given type.+definedType :: Text -> Env RdrNameStr -> Definition RdrNameStr+definedType ty = fromMaybe err . Map.lookup ty+  where+    err = error $ "definedType: Type " ++ unpack ty+                  ++ " not found in environment."++-- | Collect all the definitions in the given file (including definitions+-- nested in other messages), and assign Haskell names to them.+collectDefinitions :: FileDescriptorProto -> Env OccNameStr+collectDefinitions fd = let+    protoPrefix = case fd ^. #package of+        "" -> "."+        p -> "." <> p <> "."+    hsPrefix = ""+    in Map.fromList $ concatMap flatten $+            messageAndEnumDefs (fileSyntaxType fd)+                protoPrefix hsPrefix Map.empty+                (fd ^. #messageType) (fd ^. #enumType)++collectServices :: FileDescriptorProto -> [ServiceInfo]+collectServices fd = fmap (toServiceInfo $ fd ^. #package) $ fd ^. #service+  where+    toServiceInfo :: Text -> ServiceDescriptorProto -> ServiceInfo+    toServiceInfo pkg sd =+        ServiceInfo+            { serviceName    = sd ^. #name+            , servicePackage = pkg+            , serviceMethods = fmap toMethodInfo $ sd ^. #method+            }++    toMethodInfo :: MethodDescriptorProto -> MethodInfo+    toMethodInfo md =+        MethodInfo+            { methodName   = md ^. #name+            , methodIdent  = camelCase $ md ^. #name+            , methodInput  = fromString . T.unpack $ md ^. #inputType+            , methodOutput = fromString . T.unpack $ md ^. #outputType+            , methodClientStreaming = md ^. #clientStreaming+            , methodServerStreaming = md ^. #serverStreaming+            }++messageAndEnumDefs ::+    SyntaxType -> Text -> String+    -> GroupMap+        -- ^ Group fields of the parent message (if any).+    -> [DescriptorProto]+    -> [EnumDescriptorProto]+    -> Forest (Text, Definition OccNameStr)+        -- ^ Organized as a list of trees, to make it possible for callers+        -- to get the immediate child nested types.+messageAndEnumDefs syntaxType protoPrefix hsPrefix groups messages enums+    = map (messageDefs syntaxType protoPrefix hsPrefix groups) messages+        ++ map+            (flip Node [] -- Enums have no sub-definitions+                . enumDef syntaxType protoPrefix hsPrefix)+            enums++-- | Generate the definitions for a message and its nested types (if any).+messageDefs :: SyntaxType -> Text -> String -> GroupMap -> DescriptorProto+            -> Tree (Text, Definition OccNameStr)+messageDefs syntaxType protoPrefix hsPrefix groups d+    = Node (protoName, thisDef) subDefs+  where+    protoName = protoPrefix <> d ^. #name+    hsPrefix' = hsPrefix ++ hsName (d ^. #name) ++ "'"+    allFields = groupFieldsByOneofIndex (d ^. #field)+    thisDef =+        Message MessageInfo+            { messageName = fromString $ hsPrefix ++ hsName (d ^. #name)+              -- Set the constructor name to not conflict with enum values.+            , messageConstructorName =+                 fromString $ hsPrefix ++ hsName (d ^. #name)+                                ++ "'_constructor"+            , messageDescriptor = d+            , messageFields =+                  map (liftA2 PlainFieldInfo+                              (fieldKind syntaxType mapEntries) (fieldInfo hsPrefix'))+                      $ Map.findWithDefault [] Nothing allFields+            , messageOneofFields = collectOneofFields hsPrefix' d allFields+            , messageUnknownFields =+                  fromString $ "_" ++ hsPrefix' ++ "_unknownFields"+            , groupFieldNumber = Map.lookup protoName groups+            }+    subDefs = messageAndEnumDefs+                    syntaxType+                    (protoName <> ".")+                    hsPrefix'+                    (collectGroupFields $ d ^. #field)+                    (d ^. #nestedType)+                    (d ^. #enumType)+    -- For efficiency, only look for map entries within the immediate+    -- nested types, rather than recursively searching through all of them.+    mapEntries = collectMapEntries $ map rootLabel subDefs++-- | If this type is a map entry, retrieves the relevant information+-- along with the proto name of this type.+mapEntryInfo :: Definition OccNameStr -> Maybe MapEntryInfo+mapEntryInfo (Message m)+    | messageDescriptor m ^. #options . #mapEntry+    , [keyFd, valueFd] <- messageFields m+    = Just MapEntryInfo+                { mapEntryTypeName = messageName m+                , keyField = plainFieldInfo keyFd+                , valueField = plainFieldInfo valueFd+                }+mapEntryInfo _ = Nothing++-- | Returns a map whose keys are the proto type name of the entry message.+collectMapEntries :: [(Text, Definition OccNameStr)] -> Map.Map Text MapEntryInfo+collectMapEntries defs =+    Map.fromList+        [(protoName, e) | (protoName, d) <- defs, Just e <- [mapEntryInfo d]]++-- | A map whose keys are the proto type names of the groups in a message,+-- and values are the field numbers for those groups.+-- (Every group corresponds to exactly one message field.)+type GroupMap = Map.Map Text Int32++collectGroupFields :: [FieldDescriptorProto] -> GroupMap+collectGroupFields fs = Map.fromList+    [ (f ^. #typeName, f ^. #number)+    | f <- fs+    , f ^. #type' == FieldDescriptorProto'TYPE_GROUP+      ]++fieldInfo :: String -> FieldDescriptorProto -> FieldInfo+fieldInfo hsPrefix f = FieldInfo+                            { fieldDescriptor = f+                            , fieldName = mkFieldName hsPrefix $ f ^. #name+                            }++fieldKind ::+    SyntaxType -> Map.Map Text MapEntryInfo -> FieldDescriptorProto+    -> FieldKind+fieldKind syntaxType mapEntries f = case f ^. #label of+            FieldDescriptorProto'LABEL_OPTIONAL+                | syntaxType == Proto3+                    && f ^. #type' /= FieldDescriptorProto'TYPE_MESSAGE+                    -> OptionalValueField+                | otherwise -> OptionalMaybeField+            FieldDescriptorProto'LABEL_REQUIRED -> RequiredField+            FieldDescriptorProto'LABEL_REPEATED+                | Just entryInfo <- Map.lookup (f ^. #typeName) mapEntries+                    -> MapField entryInfo+                | otherwise -> RepeatedField packed+  where+    packed+        | f ^. #type' `elem` unpackableTypes = NotPackable+        | packedByDefault = Packed+        | otherwise = Packable+    -- If the "packed" attribute isn't set, then default to packed if proto3.+    -- Unfortunately, protoc doesn't implement this logic for us automatically.+    packedByDefault = fromMaybe (syntaxType == Proto3)+                        $ f ^. #options . #maybe'packed+    unpackableTypes =+        [ FieldDescriptorProto'TYPE_MESSAGE+        , FieldDescriptorProto'TYPE_GROUP+        , FieldDescriptorProto'TYPE_STRING+        , FieldDescriptorProto'TYPE_BYTES+        ]++collectOneofFields+    :: String -> DescriptorProto -> Map.Map (Maybe Int32) [FieldDescriptorProto]+    -> [OneofInfo]+collectOneofFields hsPrefix d allFields+    = zipWith oneofInfo [0..] $ d ^.. #oneofDecl . traverse . #name+  where+    oneofInfo idx n = OneofInfo+        { oneofFieldName = mkFieldName hsPrefix n+        , oneofTypeName = fromString $ hsPrefix ++ hsNameUnique subdefTypes n+        , oneofCases = map oneofCase+                          $ Map.findWithDefault [] (Just idx)+                              allFields+        }+    oneofCase f =+        let consName = hsPrefix ++ hsNameUnique subdefCons (f ^. #name)+        in OneofCase+            { caseField = fieldInfo hsPrefix f+            , caseConstructorName =+                  -- Note: oneof case constructors aren't prefixed+                  -- by the oneof name; field names (even inside+                  -- of a oneof) are unique within a message.+                  fromString consName+            , casePrismName =+                  fromString $ "_" ++ consName+            }+    -- Make a name that doesn't overlap with those already defined by submessages+    -- or subenums.+    hsNameUnique ns n+        | n' `elem` ns = n' ++ "'"+        | otherwise = n'+      where+        n' = hsName $ camelCase n+    -- The Haskell "type" namespace+    subdefTypes = Set.fromList $ map hsName+                    $ toListOf (#nestedType . traverse . #name) d+                    ++ toListOf (#enumType . traverse . #name) d+    -- The Haskell "expression" namespace (i.e., constructors)+    subdefCons = Set.fromList $ map hsName+                    $ toListOf (#nestedType . traverse . #name) d+                    ++ toListOf (#enumType . traverse . #value . traverse . #name) d++-- | Group fields by the index of the oneof field that they belong to.+-- (Or 'Nothing' if they don't belong to a oneof.)+groupFieldsByOneofIndex+    :: [FieldDescriptorProto] -> Map.Map (Maybe Int32) [FieldDescriptorProto]+groupFieldsByOneofIndex =+    fmap reverse+    . Map.fromListWith (++)+    . fmap (\f -> (f ^. #maybe'oneofIndex, [f]))++hsName :: Text -> String+hsName = unpack . capitalize++mkFieldName :: String -> Text -> FieldName+mkFieldName hsPrefix n = FieldName+                    { overloadedName = fromString n'+                    , haskellRecordFieldName = fromString $ "_" ++ hsPrefix ++ n'+                    }+      where+        n' = fieldBaseName n++-- | Get the name in Haskell of a proto field, taking care of camel casing and+-- clashes with language keywords.  Doesn't handle the name prefix of the+-- containing type.+fieldBaseName :: Text -> String+fieldBaseName = unpack . disambiguate . camelCase+  where+    disambiguate s+        | s `Set.member` reservedKeywords = s <> "'"+        | otherwise = s++camelCase :: Text -> Text+camelCase s =+    -- Preserve any initial underlines (e.g., "_foo_bar" -> "_fooBar").+    let (underlines, rest) = T.span (== '_') s+    in case splitOn "_" rest of+        -- splitOn always returns a list with at least one element.+        [] -> error $ "camelCase: splitOn returned empty list: "+                        ++ show rest+        [""] -> error $ "camelCase: name consists only of underscores: "+                            ++ show s+        s':ss -> T.concat $ underlines : lowerInitialChars s' : map capitalize ss++-- | Lower-case all initial upper-case characters.+-- For example: "Foo" -> "foo", "FooBar" -> "fooBar", "FOObar" -> "foobar"+lowerInitialChars :: Text -> Text+lowerInitialChars s = toLower pre <> post+  where (pre, post) = T.span isUpper s++-- | A list of reserved keywords that aren't valid as variable names.+reservedKeywords :: Set.Set Text+reservedKeywords = Set.fromList $+    -- Haskell2010 keywords:+    -- https://www.haskell.org/onlinereport/haskell2010/haskellch2.html#x7-180002.4+    -- We don't include keywords that are allowed to be variable names,+    -- in particular: "as", "forall", and "hiding".+    [ "case"+    , "class"+    , "data"+    , "default"+    , "deriving"+    , "do"+    , "else"+    , "foreign"+    , "if"+    , "import"+    , "in"+    , "infix"+    , "infixl"+    , "infixr"+    , "instance"+    , "let"+    , "module"+    , "newtype"+    , "of"+    , "then"+    , "type"+    , "where"+    ]+    ++  -- Nonstandard extensions+    [ "mdo"   -- RecursiveDo+    , "rec"   -- Arrows, RecursiveDo+    , "pattern"  -- PatternSynonyms+    , "proc"  -- Arrows+    ]++-- | Generate the definition for an enum type.+enumDef :: SyntaxType -> Text -> String -> EnumDescriptorProto+          -> (Text, Definition OccNameStr)+enumDef syntaxType protoPrefix hsPrefix d = let+    mkText n = protoPrefix <> n+    mkHsName n = fromString $ hsPrefix ++ case hsName n of+      ('_':xs) -> 'X':xs+      xs       -> xs+    in (mkText (d ^. #name)+       , Enum EnumInfo+            { enumName = mkHsName (d ^. #name)+            , enumUnrecognized = if syntaxType == Proto2+                    then Nothing+                    else Just EnumUnrecognizedInfo+                            { unrecognizedName+                                = mkHsName (d ^. #name <> "'Unrecognized")+                            , unrecognizedValueName+                                = mkHsName (d ^. #name <> "'UnrecognizedValue")+                            }+            , enumDescriptor = d+            , enumValues = collectEnumValues mkHsName $ d ^. #value+            })++-- | Generate the definitions for each enum value.  In particular, decide+-- whether it's a true constructor or a PatternSynonym to another+-- constructor.+--+-- Like Java, we treat the first case of each numeric value as the "real"+-- constructor, and subsequent cases as synonyms.+collectEnumValues :: (Text -> OccNameStr) -> [EnumValueDescriptorProto]+                  -> [EnumValueInfo OccNameStr]+collectEnumValues mkHsName = snd . mapAccumL helper Map.empty+  where+    helper :: Map.Map Int32 OccNameStr -> EnumValueDescriptorProto+           -> (Map.Map Int32 OccNameStr, EnumValueInfo OccNameStr)+    helper seenNames v+        | Just n' <- Map.lookup k seenNames = (seenNames, mkValue (Just n'))+        | otherwise = (Map.insert k n seenNames, mkValue Nothing)+      where+        mkValue = EnumValueInfo n v+        n = mkHsName (v ^. #name)+        k = v ^. #number++-- Haskell types must start with an uppercase letter, so we capitalize message+-- and enum names.+-- OccNameStr collisions will show up as build errors in the generated haskell file.+capitalize :: Text -> Text+capitalize s+    | Just (c, s') <- uncons s = cons (toUpper c) s'+    | otherwise = s++overloadedFieldName :: FieldInfo -> Symbol+overloadedFieldName = overloadedName . fieldName

@@ -0,0 +1,1054 @@+-- Copyright 2016 Google Inc. All Rights Reserved.+--+-- Use of this source code is governed by a BSD-style+-- license that can be found in the LICENSE file or at+-- https://developers.google.com/open-source/licenses/bsd++-- | This module builds the actual, generated Haskell file+-- for a given input .proto file.+{-# LANGUAGE CPP #-}+{-# LANGUAGE LambdaCase #-}+{-# LANGUAGE OverloadedLabels #-}+{-# LANGUAGE OverloadedStrings #-}+module Data.ProtoLens.Compiler.Generate(+    generateModule,+    ) where+++import Control.Arrow (second)+import qualified Data.Foldable as F+import qualified Data.List as List+import qualified Data.Map as Map+import Data.Maybe (isJust)+#if !MIN_VERSION_base(4,11,0)+import Data.Semigroup ((<>))+#endif+import Data.Ord (comparing)+import qualified Data.Set as Set+import Data.String (fromString)+import Data.Text (unpack)+import qualified Data.Text as T+import Data.Tuple (swap)+import GHC.SourceGen+import HsSyn (ideclName, ideclAs)+import Module (moduleNameString, mkModuleName)+import qualified Outputable+import SrcLoc (unLoc, noLoc)+import Lens.Family2 ((^.))+import Text.Printf (printf)++import Proto.Google.Protobuf.Descriptor+    ( EnumValueDescriptorProto+    , FieldDescriptorProto+    , FieldDescriptorProto'Type(..)+    )++import Data.ProtoLens.Compiler.Definitions+import Data.ProtoLens.Compiler.Generate.Commented+import Data.ProtoLens.Compiler.Generate.Encoding+import Data.ProtoLens.Compiler.Generate.Field+    ( hsFieldType+    , hsFieldVectorType+    )++-- Whether to import the "Runtime" modules or the originals;+-- e.g., Data.ProtoLens.Runtime.Data.Map vs Data.Map.+data UseRuntime = UseRuntime | UseOriginal+    deriving (Eq, Read)++-- | Generate a Haskell module for the given input file(s).+-- input contains all defined names, incl. those in this module+generateModule :: ModuleNameStr+               -> [ModuleNameStr]  -- ^ The imported modules+               -> [ModuleNameStr]  -- ^ The publicly imported modules+               -> Env OccNameStr      -- ^ Definitions in this file+               -> Env RdrNameStr     -- ^ Definitions in the imported modules+               -> [ServiceInfo]+               -> [CommentedModule]+generateModule modName imports publicImports definitions importedEnv services+    = [ CommentedModule pragmas+            (module' (Just modName)+                (Just $ serviceExports+                        ++ concatMap generateExports (Map.elems definitions)+                        ++ map moduleContents publicImports)+                (mainImports ++ sharedImports+                    ++ map importQualified (imports List.\\ publicImports)+                    ++ map import' publicImports)+                [])+          $ (concatMap generateDecls $ Map.toList definitions)+         ++ map uncommented (concatMap (generateServiceDecls env) services)+      , CommentedModule pragmas+            (module' (Just fieldModName) Nothing+                (sharedImports ++ map importQualified imports) [])+          $ map uncommented+          $ concatMap generateFieldDecls allLensNames+      ]+  where+    fieldModName = fromString $ moduleNameString (unModuleNameStr modName) ++ "_Fields"+    pragmas =+          [ languagePragma $ List.intercalate ", " $ map fromString+              ["ScopedTypeVariables", "DataKinds", "TypeFamilies",+               "UndecidableInstances", "GeneralizedNewtypeDeriving",+               "MultiParamTypeClasses", "FlexibleContexts", "FlexibleInstances",+               "PatternSynonyms", "MagicHash", "NoImplicitPrelude",+               "DataKinds", "BangPatterns", "TypeApplications"]+              -- Allow unused imports in case we don't import anything from+              -- Data.Text, Data.Int, etc.+          , optionsGhcPragma "-Wno-unused-imports"+            -- haskell-src-exts doesn't support exporting `Foo(..., A, B)`+            -- in a single entry, so we use two: `Foo(..)` and `Foo(A, B)`.+          , optionsGhcPragma "-Wno-duplicate-exports"+            -- Don't warn if empty "import public" modules are reexported.+          , optionsGhcPragma "-Wno-dodgy-exports"+          ]+    mainImports = map (reexported . importQualified)+                    [ "Control.DeepSeq", "Data.ProtoLens.Prism" ]+    sharedImports = map (reexported . importQualified)+              [ "Prelude", "Data.Int", "Data.Monoid", "Data.Word"+              , "Data.ProtoLens"+              , "Data.ProtoLens.Encoding.Bytes"+              , "Data.ProtoLens.Encoding.Growing"+              , "Data.ProtoLens.Encoding.Parser.Unsafe"+              , "Data.ProtoLens.Encoding.Wire"+              , "Data.ProtoLens.Field"+              , "Data.ProtoLens.Message.Enum"+              , "Data.ProtoLens.Service.Types"+              , "Lens.Family2", "Lens.Family2.Unchecked"+              , "Data.Text",  "Data.Map", "Data.ByteString", "Data.ByteString.Char8"+              , "Data.Text.Encoding"+              , "Data.Vector"+              , "Data.Vector.Generic"+              , "Data.Vector.Unboxed"+              , "Text.Read"+              ]+    env = Map.union (unqualifyEnv definitions) importedEnv+    generateDecls (protoName, Message m)+        = generateMessageDecls fieldModName env (stripDotPrefix protoName) m+       ++ map uncommented (concatMap (generatePrisms env) (messageOneofFields m))+    generateDecls (_, Enum e) = map uncommented $ generateEnumDecls e+    generateExports (Message m) = generateMessageExports m+                               ++ concatMap generatePrismExports (messageOneofFields m)+    generateExports (Enum e) = generateEnumExports e+    serviceExports = fmap generateServiceExports services+    allLensNames = F.toList $ Set.fromList+        [ lensSymbol inst+        | Message m <- Map.elems definitions+        , info <- allMessageFields env m+        , inst <- recordFieldLenses info+        ]+    -- The Env uses the convention that Message names are prefixed with '.'+    -- (since that's how the FileDescriptorProto refers to them).+    -- Strip that off when defining MessageDescriptor.messageName.+    stripDotPrefix s+        | Just ('.', s') <- T.uncons s = s'+        | otherwise = s++allMessageFields :: Env RdrNameStr -> MessageInfo OccNameStr -> [RecordField]+allMessageFields env info =+    map (plainRecordField env) (messageFields info)+        ++ map (oneofRecordField env) (messageOneofFields info)++{- We import modules as follows:++1) Modules from proto-lens-runtime: import qualified, strip the prefix:+     import qualified Data.ProtoLens.Runtime.Data.Text as Data.Text++2) Modules from "import" declarations: import qualified:+     import qualified Proto.Foo.Bar++3) Modules from "import public" declarations: import unqualified:+     import Proto.Foo.Bar+   To reexport the imported declarations from the current module via+     module ... (module Proto.Foo.Bar)+   the module Proto.Foo.Bar needs to be unqualified.+   Alternately we could explicitly enumerate every definition being reexported, but+   that would lead to less readable Haddocks and also make codegen a little more+   complicated.+-}++importQualified :: ModuleNameStr -> ImportDecl'+importQualified = qualified' . import'++type ModifyImports = ImportDecl' -> ImportDecl'++reexported :: ModifyImports+reexported imp = imp { ideclName = noLoc m', ideclAs = Just m }+  where+    m' = mkModuleName $ "Data.ProtoLens.Runtime." ++ moduleNameString (unLoc m)+    m = ideclName imp++messageComment :: ModuleNameStr -> OccNameStr -> [RecordField] -> Outputable.SDoc+messageComment fieldModName n fields =+    Outputable.vcat+        $ [Outputable.text "Fields :", ""]+            ++ map item (concatMap recordFieldLenses fields)+  where+    item :: LensInstance -> Outputable.SDoc+    item l = Outputable.text (printf "    * '%s.%s' @:: "+                 (moduleNameStrToString fieldModName)+                 (occNameStrToString $ nameFromSymbol $ lensSymbol l))+             Outputable.<>+                 (Outputable.ppr $ var "Lens'" @@ t @@ (lensFieldType l))+             Outputable.<> Outputable.char '@'+    t = var (unqual n)++generateMessageExports :: MessageInfo OccNameStr -> [IE']+generateMessageExports m =+    -- Hide the message contructor, but expose "oneof" case constructors.+    thingWith (unqual $ messageName m) []+        : map (thingAll . unqual . oneofTypeName)+                (messageOneofFields m)++generateServiceDecls :: Env RdrNameStr -> ServiceInfo -> [HsDecl']+generateServiceDecls env si =+    -- data MyService = MyService+    [ data' serverDataName []+      [ recordCon serverDataName []+      ]+      []+    ] +++    -- instance Data.ProtoLens.Service.Types.Service MyService where+    --     type ServiceName    MyService = "myService"+    --     type ServicePackage MyService = "some.package"+    --     type ServiceMethods MyService = '["normalMethod", "streamingMethod"]+    [ instance' (var "Data.ProtoLens.Service.Types.Service" @@ serverRecordType)+        [ tyFamInst "ServiceName" [serverRecordType]+                 . stringTy . T.unpack $ serviceName si+        , tyFamInst "ServicePackage" [serverRecordType]+                 . stringTy . T.unpack $ servicePackage si+        , tyFamInst "ServiceMethods" [serverRecordType]+                 $ listPromotedTy+                      [ stringTy . T.unpack $ methodIdent m+                      | m <- List.sortBy (comparing methodIdent) $ serviceMethods si+                      ]+        ]+    ] +++    -- instance Data.ProtoLens.Service.Types.HasMethodImpl MyService "normalMethod" where+    --     type MethodInput       MyService "normalMethod" = Foo+    --     type MethodOutput      MyService "normalMethod" = Bar+    --     type IsClientStreaming MyService "normalMethod" = 'False+    --     type IsServerStreaming MyService "normalMethod" = 'False+    [ instance' (var "Data.ProtoLens.Service.Types.HasMethodImpl" @@ serverRecordType @@ instanceHead)+        [ tyFamInst "MethodName" [serverRecordType, instanceHead]+                 . stringTy . T.unpack $ methodName m+        , tyFamInst "MethodInput" [serverRecordType, instanceHead]+                 . lookupType $ methodInput m+        , tyFamInst "MethodOutput" [serverRecordType, instanceHead]+                 . lookupType $ methodOutput m+        , tyFamInst "MethodStreamingType" [serverRecordType, instanceHead]+                 . tyPromotedVar+                 $ case (methodClientStreaming m, methodServerStreaming m) of+                     (False, False) -> "Data.ProtoLens.Service.Types.NonStreaming"+                     (True,  False) -> "Data.ProtoLens.Service.Types.ClientStreaming"+                     (False, True)  -> "Data.ProtoLens.Service.Types.ServerStreaming"+                     (True,  True)  -> "Data.ProtoLens.Service.Types.BiDiStreaming"+        ]+    | m <- serviceMethods si+    , let instanceHead = stringTy (T.unpack $ methodIdent m)+    ]+  where+    serverDataName = fromString . T.unpack $ serviceName si+    serverRecordType = var $ unqual serverDataName++    lookupType t = case definedType t env of+                       Message msg -> var $ messageName msg+                       Enum _ -> error "Service must have a message type"+++generateMessageDecls :: ModuleNameStr -> Env RdrNameStr -> T.Text -> MessageInfo OccNameStr -> [CommentedDecl]+generateMessageDecls fieldModName env protoName info =+    -- data Bar = Bar {+    --    foo :: Baz+    -- }+    [ commented (messageComment fieldModName (messageName info) allFields)+        $ data' dataName []+            [recordCon (messageConstructorName info) $+                [ (recordFieldName f, strict $ field $ recordFieldType f)+                | f <- allFields+                ]+                ++ [(messageUnknownFields info, strict $ field $ var "Data.ProtoLens.FieldSet")]+            ]+            [deriving' [var "Prelude.Eq", var "Prelude.Ord"]]+    -- instance Show Bar where+    --   showsPrec __x __s = showChar '{' (showString (showMessageShort __x) (showChar '}' s))+    , uncommented $+        instance' (var "Prelude.Show" @@ dataType)+            [funBind "showsPrec" $ match [bvar "_", bvar "__x", bvar "__s"]+                $ var "Prelude.showChar" @@ char '{'+                    @@ (var "Prelude.showString"+                            @@ (var "Data.ProtoLens.showMessageShort" @@ var "__x")+                        @@ (var "Prelude.showChar" @@ char '}' @@ var "__s"))]+    ] +++    -- oneof field data type declarations+    -- proto: message Foo {+    --          oneof bar {+    --            float c = 1;+    --            Sub s = 2;+    --          }+    --        }+    -- haskell: data Foo'Bar = Foo'Bar'c !Prelude.Float+    --                       | Foo'Bar's !Sub+    [ uncommented $ data' (oneofTypeName oneofInfo) []+      [ prefixCon consName [strict $ field $ hsFieldType env f]+      | c <- oneofCases oneofInfo+      , let f = caseField c+      , let consName = caseConstructorName c+      ]+      [deriving' [var "Prelude.Show", var "Prelude.Eq", var "Prelude.Ord"]]+    | oneofInfo <- messageOneofFields info+    ] +++    -- instance HasField Foo "foo" Bar+    --   fieldOf _ = ...+    -- Note: for optional fields, this generates an instance both for "foo" and+    -- for "maybe'foo" (see plainRecordField below).+    [ uncommented $ instance'+        (var "Data.ProtoLens.Field.HasField" @@ dataType @@ sym @@ t)+            [funBind "fieldOf" $ match [wildP] $+                var "Prelude.."+                    @@ rawFieldAccessor (unqual $ recordFieldName li)+                    @@ lensExp i]+    | li <- allFields+    , i <- recordFieldLenses li+    , let t = lensFieldType i+    , let sym = promoteSymbol $ lensSymbol i+    ]+    +++    -- instance Message.Message Bar where+    [ uncommented $ instance' (var "Data.ProtoLens.Message" @@ dataType)+        $ messageInstance env protoName info+    -- instance NFData Bar where+    , uncommented $ instance' (var "Control.DeepSeq.NFData" @@ dataType)+        [valBind "rnf" $ messageRnfExpr info]+    ] +++    -- instance NFData Foo'Bar where+    [ uncommented $+        instance' (var "Control.DeepSeq.NFData" @@+                        var (unqual $ oneofTypeName o))+        [funBinds "rnf" $ map oneofRnfMatch $ oneofCases o]+    | o <- messageOneofFields info+    ]+  where+    dataType = var $ unqual dataName+    dataName = messageName info+    allFields = allMessageFields env info++-- oneof Prism declarations+-- proto: message Foo {+--          oneof bar {+--            float c = 1;+--            Sub s = 2;+--          }+--        }+-- haskell: _Foo'C :: Prism' Bar'C Float+--          _Foo'S :: Prism' Bar'S Sub+--+--  example of the function definition for _Foo'C:+-- _Foo'C :: Prism' Bar'C Float+-- _Foo'C+--   = prism' Bar'C+--       (\ p__ ->+--          case p__ of+--              Bar'C p__val -> Prelude.Just p__val+--              _otherwise -> Prelude.Nothing)+generatePrisms :: Env RdrNameStr -> OneofInfo -> [HsDecl']+generatePrisms env oneofInfo =+    if length cases > 1+       then concatMap (generatePrism altOtherwise) cases+       else concatMap (generatePrism mempty) cases+    where+        cases = oneofCases oneofInfo+        altOtherwise = [match [bvar "_otherwise"] (var "Prelude.Nothing")]++        -- Generate type signature+        -- e.g. Prism' Bar'C Float+        generateTypeSig f funName =+            typeSig funName $ var "Data.ProtoLens.Prism.Prism'"+                                -- The oneof sum type name+                             @@ (var . unqual $ oneofTypeName oneofInfo)+                                -- The field contained in the sum+                             @@ (hsFieldType env f)+        -- Generate function definition+        -- Prism' is constructed with Constructor for building value+        -- and Deconstructor and wrapping in Just for getting value+        generateFunDef :: [RawMatch] -> OccNameStr -> HsExpr'+        generateFunDef otherwiseCase consName =+               var "Data.ProtoLens.Prism.prism'"+               -- Sum type constructor+            @@ var (unqual consName)+               -- Case deconstruction+            @@ (lambda [bvar "p__"] $+                    case' (var "p__") $+                       [ match [conP (unqual consName) [bvar "p__val"]]+                             $ var "Prelude.Just" @@ var "p__val"+                       ]+                       -- We want to generate the otherwise case+                       -- depending on the amount of sum type cases there are+                       ++ otherwiseCase+               )+        generatePrism :: [RawMatch] -> OneofCase -> [HsDecl']+        generatePrism otherwiseCase oneofCase =+            let consName = caseConstructorName oneofCase+                prismName = casePrismName oneofCase+            in [ generateTypeSig (caseField oneofCase) prismName+               , valBind prismName $ generateFunDef otherwiseCase consName+               ]++generatePrismExports :: OneofInfo -> [IE']+generatePrismExports = map (var . unqual . casePrismName) . oneofCases++generateEnumExports :: EnumInfo OccNameStr -> [IE']+generateEnumExports e = [thingAll n, thingWith n aliases] ++ proto3NewType+  where+    n = unqual $ enumName e+    aliases = [enumValueName v | v <- enumValues e, needsManualExport v]+    needsManualExport v = isJust (enumAliasOf v)+    proto3NewType = case enumUnrecognized e of+        Just u -> [var . unqual $ unrecognizedValueName u]+        Nothing -> []++generateServiceExports :: ServiceInfo -> IE'+generateServiceExports si = thingAll $ unqual $ fromString $ T.unpack $ serviceName si++generateEnumDecls :: EnumInfo OccNameStr -> [HsDecl']+generateEnumDecls info =+    -- Proto3-only:+    -- newtype FooEnum'UnrecognizedValue = FooEnum'UnrecognizedValue Data.Int.Int32+    --   deriving (Prelude.Eq, Prelude.Ord, Prelude.Show, Prelude.Read)+    [ newtype' (unrecognizedValueName u) []+       (prefixCon (unrecognizedValueName u) [field $ var "Data.Int.Int32"])+       [deriving' [var "Prelude.Eq", var "Prelude.Ord", var "Prelude.Show"]]+    | Just u <- [unrecognized]+    ]+    ++++    -- data FooEnum+    --     = Enum1+    --     | Enum2+    --     | FooEnum'Unrecognized !FooEnum'UnrecognizedValue+    --   deriving (Prelude.Show, Prelude.Eq, Prelude.Ord, Prelude.Read)+    [ data' dataName []+        (  (flip prefixCon [] <$> constructorNames)+        ++ [ prefixCon (unrecognizedName u)+                [strict $ field $ var $ unqual $ unrecognizedValueName u]+           | Just u <- [unrecognized]+           ]+        )+        [deriving' [var "Prelude.Show", var "Prelude.Eq", var "Prelude.Ord"]]++    -- instance Data.ProtoLens.MessageEnum FooEnum where+    --       maybeToEnum 0 = Prelude.Just Enum1+    --       maybeToEnum 3 = Prelude.Just Enum2+    --       maybeToEnum k+    --         -- Proto3:+    --         = Prelude.Just+    --             (FooEnum'Unrecognized+    --               (FooEnum'UnrecognizedValue (Prelude.fromIntegral k)))+    --         -- Proto2:+    --         = Nothing+    --+    --       showEnum Foo'Enum2 = "Enum2"+    --       showEnum Foo'Enum1 = "Enum1"+    --       showEnum (FooEnum'Unrecognized (FooEnum'UnrecognizedValue k))+    --         = Prelude.show k+    --+    --       readEnum k+    --           | k == "Enum2a" = Prelude.Just Enum2a -- alias+    --           | k == "Enum2" = Prelude.Just Enum2+    --           | k == "Enum1" = Prelude.Just Enum1+    --       readEnum k = Text.Read.readMaybe k >>= maybeToEnum+    , instance' (var "Data.ProtoLens.MessageEnum" @@ dataType)+        [ funBinds "maybeToEnum" $+            [ match [int k] $ var "Prelude.Just" @@ var (unqual c)+            | (c, k) <- constructorNumbers+            ]+            +++            [ case enumUnrecognized info of+                Nothing -> match [wildP] $ var "Prelude.Nothing"+                Just u -> match [bvar "k"]+                            $ var "Prelude.Just" @@+                                (var (unqual $ unrecognizedName u)+                                @@ (var (unqual $ unrecognizedValueName u)+                                    @@ (var "Prelude.fromIntegral" @@ var "k")+                                    )+                                )+            ]+        , funBinds "showEnum" $+            [ match [conP_ (unqual n)] $ string pn+            | v <- filter (null . enumAliasOf) $ enumValues info+            , let n = enumValueName v+            , let pn = T.unpack $ enumValueDescriptor v ^. #name+            ] +++            [ match [conP (unqual $ unrecognizedName u)+                        [conP (unqual $ unrecognizedValueName u) [bvar "k"]]+                    ]+                $ var "Prelude.show" @@ var "k"+            | Just u <- [unrecognized]+            ]+        , funBind "readEnum" $ matchGRHSs [bvar "k"] $ guardedRhs $+              [ guard (var "Prelude.==" @@ var "k" @@ string pn)+                    $ var "Prelude.Just" @@ var (unqual n)+              | v <- enumValues info+              , let n = enumValueName v+              , let pn = T.unpack $ enumValueDescriptor v ^. #name+              ]+              ++ [guard (var "Prelude.otherwise") $ var "Prelude.>>="+                                      @@ (var "Text.Read.readMaybe" @@ var "k")+                                      @@ var "Data.ProtoLens.maybeToEnum"]+        ]++      -- instance Bounded Foo where+      --    minBound = Foo1+      --    maxBound = FooN+      , instance' (var "Prelude.Bounded" @@ dataType)+          [ valBind "minBound" $ var $ unqual minBoundName+          , valBind "maxBound" $ var $ unqual maxBoundName+          ]++      -- instance Enum Foo where+      --    toEnum k = maybe (error ("Foo.toEnum: unknown argument for enum Foo: "+      --                                ++ show k))+      --                  id (maybeToEnum k)+      --    fromEnum Foo1 = 1+      --    fromEnum Foo2 = 2+      --    ..+      --    succ FooN = error "Foo.succ: bad argument FooN."+      --    succ Foo1 = Foo2+      --    succ Foo2 = Foo3+      --    ..+      --    pred Foo1 = error "Foo.succ: bad argument Foo1."+      --    pred Foo2 = Foo1+      --    pred Foo3 = Foo2+      --    ..+      --    enumFrom = messageEnumFrom+      --    enumFromTo = messageEnumFromTo+      --    enumFromThen = messageEnumFromThen+      --    enumFromThenTo = messageEnumFromThenTo+      , instance' (var "Prelude.Enum" @@ dataType)+        [funBind "toEnum" $ match [bvar "k__"]+                  $ var "Prelude.maybe" @@ errorMessageExpr @@ var "Prelude.id"+                        @@ (var "Data.ProtoLens.maybeToEnum" @@ var "k__")+        , funBinds "fromEnum" $+            [ match [conP_ (unqual c)] $ int k+            | (c, k) <- constructorNumbers+            ]+            +++            [ match [conP (unqual $ unrecognizedName u)+                                [conP (unqual $ unrecognizedValueName u) [bvar "k"]]+                                ]+                    $ var "Prelude.fromIntegral" @@ var "k"+            | Just u <- [unrecognized]+            ]+        , succDecl "succ" maxBoundName succPairs+        , succDecl "pred" minBoundName $ map swap succPairs+        , valBind "enumFrom" $ var "Data.ProtoLens.Message.Enum.messageEnumFrom"+        , valBind "enumFromTo" $ var "Data.ProtoLens.Message.Enum.messageEnumFromTo"+        , valBind "enumFromThen" $ var "Data.ProtoLens.Message.Enum.messageEnumFromThen"+        , valBind "enumFromThenTo"+            $ var "Data.ProtoLens.Message.Enum.messageEnumFromThenTo"+        ]++    -- instance Data.ProtoLens.FieldDefault Foo where+    --   fieldDefault = FirstEnumValue+    , instance' (var "Data.ProtoLens.FieldDefault" @@ dataType)+        [valBind "fieldDefault" $ defaultCon]++    -- instance NFData Foo where+    --   rnf x__ = seq x__ ()+    -- (Trivial since enum types are already strict)+    , instance' (var "Control.DeepSeq.NFData" @@ dataType)+        [ funBind "rnf" $ match [bvar "x__"]+            $ var "Prelude.seq" @@ var "x__" @@ var "()" ]+    ] ++++    -- pattern Enum2a :: FooEnum+    -- pattern Enum2a = Enum2+    concat+        [ [ patSynSig aliasName dataType+          , patSynBind aliasName [] (bvar originalName)+          ]+        | EnumValueInfo+            { enumValueName = aliasName+            , enumAliasOf = Just originalName+            } <- enumValues info+        ]++  where+    EnumInfo { enumName = dataName+             , enumUnrecognized = unrecognized+             , enumDescriptor = ed+             } = info+    errorMessage = "toEnum: unknown value for enum " ++ unpack (ed ^. #name)+                      ++ ": "++    errorMessageExpr = var "Prelude.error"+                          @@ (var "Prelude.++" @@ string errorMessage+                              @@ (var "Prelude.show" @@ var "k__"))++    dataType = var $ unqual dataName++    constructors :: [(OccNameStr, EnumValueDescriptorProto)]+    constructors = List.sortBy (comparing ((^. #number) . snd))+                            [(n, d) | EnumValueInfo+                                { enumValueName = n+                                , enumValueDescriptor = d+                                , enumAliasOf = Nothing+                                } <- enumValues info+                            ]+    constructorNames = map fst constructors++    defaultCon = var $ unqual $ head constructorNames++    minBoundName = head constructorNames+    maxBoundName = last constructorNames++    constructorNumbers = map (second (fromIntegral . (^. #number))) constructors++    succPairs = zip constructorNames $ tail constructorNames++    succDecl :: OccNameStr -> OccNameStr -> [(OccNameStr, OccNameStr)] -> RawInstDecl+    succDecl funName boundName thePairs = funBinds funName $+        match [conP_ (unqual boundName)]+            (var "Prelude.error" @@ string (concat+                [ occNameStrToString dataName, "."+                , occNameStrToString funName, ": bad argument "+                , occNameStrToString boundName+                , ". This value would be out of bounds."+                ]))+        :+        [ match [conP_ (unqual from)] $ var $ unqual to+        | (from, to) <- thePairs+        ]+        +++        [ match [conP (unqual $ unrecognizedName u) [wildP]]+            (var "Prelude.error" @@ string (concat+                [ occNameStrToString dataName, "."+                , occNameStrToString funName, ": bad argument: unrecognized value"++                ]))+        | Just u <- [unrecognized]+        ]++generateFieldDecls :: Symbol -> [HsDecl']+generateFieldDecls xStr =+    -- foo :: forall f s a+    --        . (Functor f, HasLens s x a) => LensLike' f s a+    -- foo = fieldOf @s+    [ typeSig x+          $ forall' [bvar "f", bvar "s", bvar "a"]+          $ [ var "Prelude.Functor" @@ var "f"+            , var "Data.ProtoLens.Field.HasField" @@ var "s" @@ xSym @@ var "a"+            ]+          ==> var "Lens.Family2.LensLike'" @@ var "f" @@ var "s" @@ var "a"+    , valBind x $ fieldOfExp xStr+    ]+  where+    x = nameFromSymbol xStr+    xSym = promoteSymbol xStr++------------------------------------------++-- | An individual field of the Haskell type corresponding to a proto message.+data RecordField = RecordField+    { recordFieldName :: OccNameStr  -- ^ The Haskell name of this field (unique+                               --   within the module).+    , recordFieldType :: HsType'  -- ^ Internal type in the record+    , recordFieldLenses :: [LensInstance]+        -- ^ All of the (overloaded) lenses accessing this record field.+    }++-- | An instance of HasLens' for a particular field.+data LensInstance = LensInstance+    { lensSymbol :: Symbol+          -- ^ The overloaded name for this lens.+    , lensFieldType :: HsType'+          -- ^ The type pointed to from this lens.+    , lensExp :: HsExpr'+        -- ^ A lens from the recordFieldType to the lensFieldType; i.e.,+        -- from how it's actually stored in the Haskell record to how the+        -- lens views it.+    }++-- | Compile information about the record field type and type/class instances+-- for this particular field.+--+-- Used for "plain" record fields that are not part of a oneof.+plainRecordField :: Env RdrNameStr -> PlainFieldInfo -> RecordField+plainRecordField env (PlainFieldInfo kind f) = case kind of+    -- data Foo = Foo { _Foo_bar :: Bar }+    -- type instance Field "bar" Foo = Bar+    RequiredField+        -> recordField baseType+                  [LensInstance+                      { lensSymbol = baseName+                      , lensFieldType = baseType+                      , lensExp = rawAccessor+                      }]+    OptionalValueField+              -> recordField baseType+                    [LensInstance+                      { lensSymbol = baseName+                      , lensFieldType = baseType+                      , lensExp = rawAccessor+                      }]+    -- data Foo = Foo { _Foo_bar :: Maybe Bar }+    -- type instance Field "bar" Foo = Bar+    -- type instance Field "maybe'bar" Foo = Maybe Bar+    OptionalMaybeField ->+              recordField maybeType+                  [LensInstance+                      { lensSymbol = baseName+                      , lensFieldType = baseType+                      , lensExp = maybeAccessor+                      }+                  , LensInstance+                      { lensSymbol = "maybe'" <> baseName+                      , lensFieldType = maybeType+                      , lensExp = rawAccessor+                      }+                  ]+        -- data Foo = Foo { _Foo_bar :: Map Bar Baz }+        -- type instance Field "foo" Foo = Map Bar Baz+    MapField entry ->+            let mapType = var "Data.Map.Map"+                            @@ hsFieldType env (keyField entry)+                            @@ hsFieldType env (valueField entry)+            in recordField mapType+                  [LensInstance+                       { lensSymbol = baseName+                       , lensFieldType = mapType+                       , lensExp = rawAccessor+                       }]+        -- data Foo = Foo { _Foo_bar :: [Bar] }+        -- type instance Field "bar" Foo = [Bar]+    RepeatedField {} ->+            recordField vectorType+                  [ LensInstance+                      { lensSymbol = baseName+                      , lensFieldType = listType+                      , lensExp = vectorAccessor+                      }+                  , LensInstance+                      { lensSymbol = "vec'" <> baseName+                      , lensFieldType = vectorType+                      , lensExp = rawAccessor+                      }+                  ]+  where+    recordField = RecordField (haskellRecordFieldName $ fieldName f)+    baseName = overloadedName $ fieldName f+    fd = fieldDescriptor f+    baseType = hsFieldType env f+    maybeType = var "Prelude.Maybe" @@ baseType+    listType = listTy baseType+    vectorType = hsFieldVectorType f @@ baseType+    rawAccessor = var "Prelude.id"+    maybeAccessor = var "Data.ProtoLens.maybeLens"+                          @@ hsFieldValueDefault env fd++vectorAccessor :: HsExpr'+vectorAccessor = var "Lens.Family2.Unchecked.lens" @@ getter @@ setter+  where+    getter = var "Data.Vector.Generic.toList"+    setter = lambda [wildP, bvar "y__"]+                $ var "Data.Vector.Generic.fromList" @@ var "y__"++oneofRecordField :: Env RdrNameStr -> OneofInfo -> RecordField+oneofRecordField env oneofInfo+    = RecordField+        { recordFieldName = haskellRecordFieldName $ oneofFieldName oneofInfo+        , recordFieldType =+              var "Prelude.Maybe" @@ var (unqual $ oneofTypeName oneofInfo)+        , recordFieldLenses = lenses+        }+  where+    lenses =+        -- Only generate a "maybe" version of this lens,+        -- since oneofs don't have a notion of a "default" case.+        -- data Foo = Foo { _Foo'bar = Maybe Foo'Bar }+        -- type instance Field "maybe'bar" Foo = Maybe Foo'Bar+        [LensInstance+          { lensSymbol = "maybe'" <> overloadedName+                                        (oneofFieldName oneofInfo)+          , lensFieldType =+                var "Prelude.Maybe" @@ var (unqual $ oneofTypeName oneofInfo)+          , lensExp = var "Prelude.id"+          }+         ]+         ++ concat+          -- Generate the same lenses for each sub-field of the oneof+          -- as if they were proto2 optional fields.+          -- type instance Field "bar" Foo = Bar+          -- type instance Field "maybe'bar" Foo = Maybe Bar+            [ [ LensInstance+                { lensSymbol = maybeName+                , lensFieldType = var "Prelude.Maybe" @@ baseType+                , lensExp = oneofFieldAccessor c+                }+              , LensInstance+                { lensSymbol = baseName+                , lensFieldType = baseType+                , lensExp = var "Prelude.."+                                @@ oneofFieldAccessor c+                                @@ (var "Data.ProtoLens.maybeLens"+                                              @@ hsFieldValueDefault env+                                                    (fieldDescriptor f))+                }+              ]+            | c <- oneofCases oneofInfo+            , let f = caseField c+            , let baseName = overloadedName $ fieldName f+            , let baseType = hsFieldType env f+            , let maybeName = "maybe'" <> baseName+            ]++hsFieldDefault :: Env RdrNameStr -> PlainFieldInfo -> HsExpr'+hsFieldDefault env f = case plainFieldKind f of+    RequiredField -> hsFieldValueDefault env fd+    OptionalValueField -> hsFieldValueDefault env fd+    OptionalMaybeField -> var "Prelude.Nothing"+    MapField {} -> var "Data.Map.empty"+    RepeatedField {} -> var "Data.Vector.Generic.empty"+  where+    fd = fieldDescriptor (plainFieldInfo f)++hsFieldValueDefault :: Env RdrNameStr -> FieldDescriptorProto -> HsExpr'+hsFieldValueDefault env fd = case fd ^. #type' of+    FieldDescriptorProto'TYPE_MESSAGE -> var "Data.ProtoLens.defMessage"+    FieldDescriptorProto'TYPE_GROUP -> var "Data.ProtoLens.defMessage"+    FieldDescriptorProto'TYPE_ENUM+        | T.null def -> var "Data.ProtoLens.fieldDefault"+        | Enum e <- definedFieldType fd env+        , Just v <- List.lookup def [ (enumValueDescriptor v ^. #name, enumValueName v)+                                    | v <- enumValues e+                                    ]+            -> var v+        | otherwise -> errorMessage "enum"+    -- The rest of the cases are for scalar fields that have a fieldDefault+    -- instance.+    _ | T.null def -> var "Data.ProtoLens.fieldDefault"+    FieldDescriptorProto'TYPE_BOOL+        | def == "true" -> var "Prelude.True"+        | def == "false" -> var "Prelude.False"+        | otherwise -> errorMessage "bool"+    FieldDescriptorProto'TYPE_STRING+        -> var "Data.Text.pack" @@ string (T.unpack def)+    FieldDescriptorProto'TYPE_BYTES+        -> var "Data.ByteString.pack"+                @@ list ((mkByte . fromEnum) <$> T.unpack def)+      where mkByte c+              | c > 0 && c < 255 = int $ fromIntegral c+              | otherwise = errorMessage "bytes"+    FieldDescriptorProto'TYPE_FLOAT -> defaultFrac $ T.unpack def+    FieldDescriptorProto'TYPE_DOUBLE -> defaultFrac $ T.unpack def+    -- Otherwise, assume it's an integral field:+    _ -> defaultInt $ T.unpack def+  where+    def = fd ^. #defaultValue+    errorMessage fieldType+        = error $ "Bad default value " ++ show (T.unpack def)+                    ++ " in default value for " ++ fieldType ++ " field "+                    ++ unpack (fd ^. #name)+    -- float/double fields can use nan, inf and -inf as default values.+    -- The Prelude doesn't provide names for them, so we implement+    -- them as division by zero.+    defaultFrac "nan" = var "Prelude./" @@ frac 0 @@ frac 0+    defaultFrac "inf" = var "Prelude./" @@ frac 1 @@ frac 0+    defaultFrac "-inf" = var "Prelude./" @@ frac (negate 1) @@ frac 0+    defaultFrac s = case reads s of+        [(x, "")] -> frac $ toRational (x :: Double)+        _ -> errorMessage "fractional"+    defaultInt s = case reads s of+        [(x, "")] -> int x+        _ -> errorMessage "integral"++-- | A lens to access an internal field.+--+--   lens _Foo_bar (\x__ y__ -> x__ { _Foo_bar = y__ })+rawFieldAccessor :: RdrNameStr -> HsExpr'+rawFieldAccessor f = var "Lens.Family2.Unchecked.lens" @@ getter @@ setter+  where+    getter = var f+    setter = lambda [bvar "x__", bvar "y__"]+                    $ recordUpd (var "x__") [(f, var "y__")]++-- | A lens that maps from a oneof sum type to one of its individual cases.+--+-- For example, with+--     data Foo = Bar Int32 | Baz Int64+--+-- this will generate a lens of type @Lens' (Maybe Foo) (Maybe Int32)@.+--+-- (Recall that oneofs are stored in a proto message as @Maybe Foo@, where+-- 'Nothing' means that it's either set to an unknown value or unset.)+--+-- lens+--   (\ x__ -> case x__ of+--       Prelude.Just (Foo'c x__val) -> Prelude.Just x__val+--       otherwise -> Prelude.Nothing)+--   (\ _ y__ -> fmap Foo'c y__+oneofFieldAccessor :: OneofCase -> HsExpr'+oneofFieldAccessor o+        = var "Lens.Family2.Unchecked.lens" @@ getter @@ setter+  where+    consName = caseConstructorName o+    getter = lambda [bvar "x__"] $+        case' (var "x__")+            [ match [conP "Prelude.Just" [conP (unqual consName) [bvar "x__val"]]]+                $ var "Prelude.Just" @@ var "x__val"+            , match [bvar "_otherwise"] $ var "Prelude.Nothing"+            ]+    setter = lambda [wildP, bvar "y__"]+                $ var "Prelude.fmap" @@ var (unqual consName) @@ var "y__"++messageInstance :: Env RdrNameStr -> T.Text -> MessageInfo OccNameStr -> [RawInstDecl]+messageInstance env protoName m =+    [ funBind "messageName" $ match [wildP] $+          var "Data.Text.pack" @@ string (T.unpack protoName)+    , valBind "fieldsByTag" $+          let' (map (fieldDescriptorVarBind $ messageName m) $ fields)+              $ var "Data.Map.fromList" @@ list fieldsByTag+    , valBind "unknownFields"+           $ rawFieldAccessor (unqual $ messageUnknownFields m)+    , valBind "defMessage"+           $ recordConE (unqual $ messageConstructorName m) $+                  [ (unqual $ haskellRecordFieldName+                                    $ fieldName $ plainFieldInfo f,+                        hsFieldDefault env f)+                  | f <- messageFields m+                  ] +++                  [ (unqual $ haskellRecordFieldName $ oneofFieldName o,+                        var "Prelude.Nothing")+                  | o <- messageOneofFields m+                  ] +++                  [ (unqual $ messageUnknownFields m, var "[]")]+    , valBind "parseMessage" $ generatedParser env m+    , valBind "buildMessage" $ generatedBuilder m+    ]+  where+    fieldsByTag =+        [tuple+              [ t, fieldDescriptorVar f ]+              | f <- fields+              , let t = var "Data.ProtoLens.Tag"+                          @@ int (fromIntegral+                                      $ fieldDescriptor (plainFieldInfo f) ^. #number)+              ]+    fieldDescriptorVar = var . unqual . fieldDescriptorName+    fieldDescriptorName f+        = nameFromSymbol $ overloadedName (fieldName . plainFieldInfo $ f)+                                <> "__field_descriptor"+    fieldDescriptorVarBind n f+        = valBind (fieldDescriptorName f)+            $ fieldDescriptorExpr env n f+    fields = messageFields m+                ++ (messageOneofFields m >>= fmap casePlainField . oneofCases)+    -- The cases of an optional are always treated like proto2 "maybe" fields.+    casePlainField = PlainFieldInfo OptionalMaybeField . caseField++-- | Get the name of the field when used in a text format proto. Groups are+-- special because their text format field name is the name of their type,+-- not the name of the field in the descriptor (e.g. "Foo", not "foo").+textFormatFieldName :: Env RdrNameStr -> FieldDescriptorProto -> T.Text+textFormatFieldName env descr = case descr ^. #type' of+    FieldDescriptorProto'TYPE_GROUP+        | Message msg <- definedFieldType descr env+              -> messageDescriptor msg ^. #name+        | otherwise -> error $ "expected TYPE_GROUP for type name"+                           ++ T.unpack (descr ^. #typeName)+    _ -> descr ^. #name++fieldDescriptorExpr :: Env RdrNameStr -> OccNameStr -> PlainFieldInfo+                    -> HsExpr'+fieldDescriptorExpr env n f =+    (var "Data.ProtoLens.FieldDescriptor"+        -- Record the original .proto name for text format+        @@ string (T.unpack $ textFormatFieldName env fd)+        -- Force the type signature since it can't be inferred for Map entry+        -- types.+        @@ (fieldTypeDescriptorExpr (fd ^. #type')+                @::@+                    (var "Data.ProtoLens.FieldTypeDescriptor"+                        @@ hsFieldType env (plainFieldInfo f)))+        @@ fieldAccessorExpr f)+    -- TODO: why is this type sig needed?+    @::@+    (var "Data.ProtoLens.FieldDescriptor" @@ var (unqual n))+  where+    fd = fieldDescriptor $ plainFieldInfo f++fieldAccessorExpr :: PlainFieldInfo -> HsExpr'+-- (PlainField Required foo), (OptionalField foo), etc...+fieldAccessorExpr (PlainFieldInfo kind f) = accessorCon @@ fieldOfExp hsFieldName++  where+    accessorCon = case kind of+          RequiredField+                -> var "Data.ProtoLens.PlainField" @@ var "Data.ProtoLens.Required"+          OptionalValueField+                -> var "Data.ProtoLens.PlainField" @@ var "Data.ProtoLens.Optional"+          OptionalMaybeField+                -> var "Data.ProtoLens.OptionalField"+          MapField entry+                  -> var "Data.ProtoLens.MapField"+                         @@ fieldOfExp (overloadedField $ keyField entry)+                         @@ fieldOfExp (overloadedField $ valueField entry)+          RepeatedField packed ->+                var "Data.ProtoLens.RepeatedField"+                  @@ if packed == Packed+                        then var "Data.ProtoLens.Packed"+                        else var "Data.ProtoLens.Unpacked"+    hsFieldName+        = case kind of+            OptionalMaybeField -> "maybe'" <> overloadedField f+            _ -> overloadedField f++fieldOfExp :: Symbol -> HsExpr'+fieldOfExp sym = var "Data.ProtoLens.Field.field" `tyApp` promoteSymbol sym++overloadedField :: FieldInfo -> Symbol+overloadedField = overloadedName . fieldName++fieldTypeDescriptorExpr :: FieldDescriptorProto'Type -> HsExpr'+fieldTypeDescriptorExpr = \case+    FieldDescriptorProto'TYPE_DOUBLE -> mk "ScalarField" "DoubleField"+    FieldDescriptorProto'TYPE_FLOAT -> mk "ScalarField" "FloatField"+    FieldDescriptorProto'TYPE_INT64 -> mk "ScalarField" "Int64Field"+    FieldDescriptorProto'TYPE_UINT64 -> mk "ScalarField" "UInt64Field"+    FieldDescriptorProto'TYPE_INT32 -> mk "ScalarField" "Int32Field"+    FieldDescriptorProto'TYPE_FIXED64 -> mk "ScalarField" "Fixed64Field"+    FieldDescriptorProto'TYPE_FIXED32 -> mk "ScalarField" "Fixed32Field"+    FieldDescriptorProto'TYPE_BOOL -> mk "ScalarField" "BoolField"+    FieldDescriptorProto'TYPE_STRING -> mk "ScalarField" "StringField"+    FieldDescriptorProto'TYPE_GROUP -> mk "MessageField" "GroupType"+    FieldDescriptorProto'TYPE_MESSAGE -> mk "MessageField" "MessageType"+    FieldDescriptorProto'TYPE_BYTES -> mk "ScalarField" "BytesField"+    FieldDescriptorProto'TYPE_UINT32 -> mk "ScalarField" "UInt32Field"+    FieldDescriptorProto'TYPE_ENUM -> mk "ScalarField" "EnumField"+    FieldDescriptorProto'TYPE_SFIXED32 -> mk "ScalarField" "SFixed32Field"+    FieldDescriptorProto'TYPE_SFIXED64 -> mk "ScalarField" "SFixed64Field"+    FieldDescriptorProto'TYPE_SINT32 -> mk "ScalarField" "SInt32Field"+    FieldDescriptorProto'TYPE_SINT64 -> mk "ScalarField" "SInt64Field"+  where+    mk x y = var (fromString ("Data.ProtoLens." ++ x))+              @@ var (fromString ("Data.ProtoLens." ++ y))++-- | Generate the implementation of NFData.rnf for the given message.+--+-- instance NFData Bar where+--    rnf = \x -> deepseq (_Bar'foo x) (deepseq (_Bar'bar x) ())+messageRnfExpr :: MessageInfo OccNameStr -> HsExpr'+messageRnfExpr msg = lambda [bvar "x__"] $ foldr (@@) unit (map seqField fieldNames)+  where+    fieldNames = messageUnknownFields msg+                : map (haskellRecordFieldName . fieldName . plainFieldInfo)+                       (messageFields msg)+                ++ map (haskellRecordFieldName . oneofFieldName)+                       (messageOneofFields msg)+    seqField :: OccNameStr -> HsExpr'+    seqField f = var "Control.DeepSeq.deepseq" @@ (var (unqual f) @@ var "x__")++--   rnf (Foo'a x__) = rnf x__+--   rnf (Bar'b x__) = rnf x__+oneofRnfMatch :: OneofCase -> RawMatch+oneofRnfMatch c = match [unqual (caseConstructorName c) `conP` [bvar "x__"]]+                    $ var "Control.DeepSeq.rnf" @@ var "x__"

@@ -0,0 +1,48 @@+-- | Enables pretty-printing Haddock comments along with top-level declarations.+module Data.ProtoLens.Compiler.Generate.Commented where++import Data.Maybe (fromMaybe)+import GHC.SourceGen+import Outputable (Outputable(..), SDoc, (<+>), ($+$), vcat, empty, text)+import HsSyn (hsmodName)+import GHC (ModuleName)+import SrcLoc (unLoc)++-- | A declaration, along with an optional comment.+--+-- GHC's pretty-printer omits the contents of comments, so we can't use it here.+data CommentedDecl = CommentedDecl (Maybe SDoc) HsDecl'++instance Outputable CommentedDecl where+    ppr (CommentedDecl maybeComment decl) =+        maybe empty pprComment maybeComment+        $+$ ppr decl+      where+        pprComment c = text "{- |" <+> c <+> text "-}"++uncommented :: HsDecl' -> CommentedDecl+uncommented = CommentedDecl Nothing++commented :: SDoc -> HsDecl' -> CommentedDecl+commented = CommentedDecl . Just++data CommentedModule = CommentedModule+    { pragmaComments :: [String]+    , moduleHeader :: HsModule'+    , commentedDecls :: [CommentedDecl]+    }++getModuleName :: CommentedModule -> ModuleName+getModuleName m =+    fromMaybe (error $ "getModuleName: No explicit name")+        $ fmap unLoc $ hsmodName $ moduleHeader m++instance Outputable CommentedModule where+    ppr m =+        vcat (map text $ pragmaComments m)+        $+$ ppr (moduleHeader m)+        $+$ vcat (map ppr $ commentedDecls m)++languagePragma, optionsGhcPragma :: String -> String+languagePragma s = "{-# LANGUAGE " ++ s ++ "#-}"+optionsGhcPragma s = "{-# OPTIONS_GHC " ++ s ++ "#-}"

@@ -0,0 +1,638 @@+-- | This module generates code for decoding and encoding protocol buffer messages.+--+-- Upstream docs: <https://developers.google.com/protocol-buffers/docs/encoding>+{-# LANGUAGE CPP #-}+{-# LANGUAGE DeriveFunctor #-}+{-# LANGUAGE LambdaCase #-}+{-# LANGUAGE NoMonomorphismRestriction #-}+{-# LANGUAGE OverloadedLabels #-}+{-# LANGUAGE OverloadedStrings #-}+module Data.ProtoLens.Compiler.Generate.Encoding+    ( generatedParser+    , generatedBuilder+    ) where++import Data.Int (Int32)+import qualified Data.Map as Map+#if !MIN_VERSION_base(4,11,0)+import Data.Semigroup ((<>))+#endif+import qualified Data.Text as Text+import Lens.Family2 (view, (^.))+import GHC.SourceGen++import Data.ProtoLens.Compiler.Definitions+import Data.ProtoLens.Compiler.Generate.Field+import Data.ProtoLens.Encoding.Wire (joinTypeAndTag)++generatedParser :: Env RdrNameStr -> MessageInfo OccNameStr -> HsExpr'+generatedParser env m =+    {- let loop :: T -> Bool -> Bool -> ...+                   -> MVector RealWorld Int32 -> MVector RealWorld Float -> ...+                   -> Parser T+           loop x required'a required'b ... mutable'a mutable'b ... = ...+       in "package.T" <?> do+            mutable'a <- unsafeLiftIO new+            mutable'b <- unsafeLiftIO new+            ...+            loop defMessage True True ... mutable'a mutable'b ...+    -}+    let' [typeSig loop loopSig+         , funBind loop $ match (bvar <$> loopArgs names) loopExpr+         ]+        $ var "Data.ProtoLens.Encoding.Bytes.<?>"+           @@ do' (startStmts ++ [stmt $ continue startExp])+           @@ string msgName+  where+    ty = var (unqual $ messageName m)+    msgName = Text.unpack (messageDescriptor m ^. #name)+    loopSig = foldr (-->)+        (var "Data.ProtoLens.Encoding.Bytes.Parser" @@ ty)+        (loopArgs $ parseStateTypes env m)++    names = parseStateNames m+    exprs = fmap (var . unqual) names+    tag = bvar "tag"+    end = bvar "end"+    loop = "loop"++    (startStmts, startExp) = startParse names++    continue :: ParseState HsExpr' -> HsExpr'+    continue s = foldl (@@) (var loop) (loopArgs s)++    loopExpr+        {- Group:+            do+              tag <- getVarInt+              case tag of+                {groupEndTag} -> {finish}+                ... -- Regular message fields++          TODO(#282): fail the parse if we find a group-end tag+          with an incorrect field number.+        -}+        | Just g <- groupFieldNumber m = do'+            [ tag <-- getVarInt'+            , stmt $ case' tag $+                (match [int (groupEndTag g)] (finish m exprs))+                    : parseTagCases continue exprs m+            ]+        {- Regular message type:+              do+                end <- atEnd+                if end+                    then {finish}+                    else do+                        tag <- getVarInt+                        case tag of ...+        -}+        | otherwise = do'+            [ end <-- var "Data.ProtoLens.Encoding.Bytes.atEnd"+            , stmt $+                if' end (finish m exprs)+                    $ do'+                        [ tag <-- getVarInt'+                        , stmt $ case' tag $ parseTagCases continue exprs m+                        ]+            ]++-- | A Parser expression that finalizes the message.+finish :: MessageInfo OccNameStr -> ParseState HsExpr' -> HsExpr'+finish m s = do' $+    {- do+        frozen'a <- unsafeLiftIO $ unsafeFreeze mutable'a+        frozen'b <- unsafeLiftIO $ unsafeFreeze mutable'b+        ...+        {checkMissingFields}+        over unknownFields reverse+            $ set field @"vec'a" frozen'a+            $ set field @"vec'b" frozen'b+            ...+            $ {partialMessage}+    -}+    [ bvar frozen <-- unsafeLiftIO' @@+                    (var "Data.ProtoLens.Encoding.Growing.unsafeFreeze"+                        @@ mutable)+    | (frozen, mutable) <- Map.elems $ Map.intersectionWith (,)+                                frozenNames (repeatedFieldMVectors s)+    ]+    +++    [ stmt $ checkMissingFields s+    , stmt $ var "Prelude.return" @@+        (over' unknownFields' (var "Prelude.reverse")+            @@(foldr (@@)+                (partialMessage s)+                (Map.intersectionWith+                    (\finfo frozen ->+                        var "Lens.Family2.set"+                            @@ fieldOfVector finfo+                            @@ var (unqual frozen))+                repeatedInfos frozenNames)))+            ]++  where+    repeatedInfos = repeatedFields m+    frozenNames = (\f -> nameFromSymbol $ "frozen'" <> overloadedFieldName f)+                    <$> repeatedInfos++-- | The state of the parsing loop.  Each instance of @v@ corresponds+-- to an argument of the loop function.+data ParseState v = ParseState+    { partialMessage :: v+        -- ^ The message that we're parsing.+    , requiredFieldsUnset :: Map.Map FieldId v+        -- ^ The required fields of the message, each corresponding to+        -- a @Bool@ argument of the loop.+    , repeatedFieldMVectors :: Map.Map FieldId v+        -- ^ The repeated fields of the message, each corresponding to+        -- an @MVector@ argument of the loop.+    } deriving Functor++-- | Returns a sequence of all arguments of the loop function.+loopArgs :: ParseState v -> [v]+loopArgs s = partialMessage s : Map.elems (requiredFieldsUnset s)+                                ++ Map.elems (repeatedFieldMVectors s)++-- | The proto name of the field.+newtype FieldId = FieldId Text.Text+    deriving (Eq, Ord)++fieldId :: PlainFieldInfo -> FieldId+fieldId f = FieldId $ fieldDescriptor (plainFieldInfo f) ^. #name++-- | The names of the loop arguments.+parseStateNames :: MessageInfo OccNameStr -> ParseState OccNameStr+parseStateNames m = ParseState+    { partialMessage = "x"+    , requiredFieldsUnset = Map.fromList+        [ (fieldId f, nameFromSymbol $ "required'" <> n)+        | f <- messageFields m+        , let info = plainFieldInfo f+        , let n = overloadedFieldName info+        , RequiredField <- [plainFieldKind f]+        ]+    , repeatedFieldMVectors =+        (\f -> nameFromSymbol $ "mutable'" <> overloadedFieldName f)+            <$> repeatedFields m+    }++repeatedFields :: MessageInfo OccNameStr -> Map.Map FieldId FieldInfo+repeatedFields m = Map.fromList+    [ (fieldId f, plainFieldInfo f)+    | f <- messageFields m+    , RepeatedField{} <- [plainFieldKind f]+    ]++-- | Intialize the values of the loop arguments.+startParse :: ParseState OccNameStr -> ([Stmt'], ParseState HsExpr')+startParse names =+    ([ bvar n <-- unsafeLiftIO' @@ var "Data.ProtoLens.Encoding.Growing.new"+     | n <- Map.elems mvectorNames+     ]+    , ParseState+        { partialMessage = var "Data.ProtoLens.defMessage"+        , requiredFieldsUnset = const (var "Prelude.True")+                                    <$> requiredFieldsUnset names+        , repeatedFieldMVectors = var . unqual <$> mvectorNames+        }+    )+  where+    mvectorNames = repeatedFieldMVectors names++-- | The types of the loop arguments.+parseStateTypes :: Env RdrNameStr -> MessageInfo OccNameStr -> ParseState HsType'+parseStateTypes env m = ParseState+    { partialMessage = var $ unqual $ messageName m+    , requiredFieldsUnset = fmap (const $ var "Prelude.Bool")+                            $ requiredFieldsUnset+                            $ parseStateNames m+    , repeatedFieldMVectors = growingType env <$> repeatedFields m+    }++-- | Transform the loop arguments by applying a given function+-- to the intermediate message value.+updateParseState ::+       HsExpr' -- ^ An expression of type @msg -> msg@+    -> ParseState HsExpr'+    -> ParseState HsExpr'+updateParseState f s = s { partialMessage = f @@ (partialMessage s) }++-- | Transform the loop arguments by marking a required field+-- as having been set.+markRequiredField :: FieldId -> ParseState HsExpr' -> ParseState HsExpr'+markRequiredField f s =+    s { requiredFieldsUnset = Map.insert f (var "Prelude.False")+                                $ requiredFieldsUnset s }++-- | Append to the given repeated field.+appendToRepeated :: FieldId -> HsExpr' -> ParseState HsExpr' -> (Stmt', ParseState HsExpr')+appendToRepeated f x s =+    ( v <-- unsafeLiftIO'+                @@ (var "Data.ProtoLens.Encoding.Growing.append"+                        @@ (repeatedFieldMVectors s Map.! f)+                        @@ x)+    , s { repeatedFieldMVectors =+                            Map.insert f v+                                $ repeatedFieldMVectors s+                        }+    )+  where+    v = bvar "v"++-- | Returns an HsExpr' of type @Parser ()@+-- which fails if any of the missing fields aren't set.+checkMissingFields :: ParseState HsExpr' -> HsExpr'+checkMissingFields s =+    {- let missing = (if required'a then ("a":) else id)+                        ((if required'b then ("b":) else id)+                        ... [])+       in if null missing then return ()+          else fail ("Missing required fields: " ++ show missing)+    -}+    let' [valBind missing $ allMissingFields]+    $ if' (var "Prelude.null" @@ var missing) (var "Prelude.return" @@ unit)+    $ var "Prelude.fail"+        @@ (var "Prelude.++"+                @@ string "Missing required fields: "+                @@ (var "Prelude.show" @@ (var missing @::@ listTy (var "Prelude.String"))))+  where+    missing = "missing"+    allMissingFields = Map.foldrWithKey consIfMissing (list []) (requiredFieldsUnset s)+    consIfMissing (FieldId f) e rest =+        (if' e (cons @@ string (Text.unpack f)) (var "Prelude.id")) @@ rest++-- | A list case alternatives for the fields of a message.+--+-- The exact structure of each case differs based on the field type.  However, it+-- generally looks like:+--+-- @+--   {N} -> do+--           {VALUE} <- {PARSE}+--           loop (set {FIELD} {VALUE} x) required'a False required'c ...+-- @+--+-- where:+--  - {N} is an integer representing the wire type + field number,+--  - {VALUE} is an expression of type "V", which is the type of the field,+--  - {PARSE} is an expression of the form "Parser V",+--  - and "loop" and "x" are as in @generatedParser@.+parseTagCases ::+       (ParseState HsExpr' -> HsExpr')+            -- ^ loop continuation, equivalent to "msg -> Bool -> ... -> Bool -> Parser msg".+            -- It continues the loop with the given new value of the message, keeping track+            -- of whether the required fields are still needed.+    -> ParseState HsExpr' -- ^ Previous value of the message and required field states+    -> MessageInfo OccNameStr+    -> [RawMatch]+parseTagCases loop x info =+    concatMap (parseFieldCase loop x) allFields+    -- TODO: currently we ignore unknown fields.+    ++ [unknownFieldCase info loop x]+  where+    allFields = messageFields info+                -- Cases of a oneof are decoded like optional oneof fields.+                ++ [ PlainFieldInfo OptionalMaybeField (caseField c)+                   | o <- messageOneofFields info+                   , c <- oneofCases o+                   ]++-- | A particular parsing case.  See @parseTagCases@ for details.+parseFieldCase ::+    (ParseState HsExpr' -> HsExpr') -> ParseState HsExpr' -> PlainFieldInfo -> [RawMatch]+parseFieldCase loop x f = case plainFieldKind f of+    MapField entryInfo -> [mapCase entryInfo]+    RepeatedField p+        | p == NotPackable -> [unpackedCase]+        | otherwise -> [unpackedCase, packedCase]+    RequiredField -> [requiredCase]+    _ -> [valueCase]+  where+    y = bvar "y"+    entry = bvar "entry"+    info = plainFieldInfo f+    valueCase = match [int (fieldTag info)] $ do'+        [ y <-- parseField info+        , stmt . loop . updateParseState (setField info @@ y)+            $ x+        ]+    requiredCase = match [int (fieldTag info)] $ do'+        [ y <-- parseField info+        , stmt . loop+               . updateParseState (setField info @@ y)+               . markRequiredField (fieldId f)+               $ x+        ]+    unpackedCase = match [int (fieldTag info)]+        $ let (appendStmt, x') = appendToRepeated (fieldId f) y x+        in do'+            [ strictP y <-- parseField info+            , appendStmt+            , stmt . loop $ x'+            ]+    packedCase = match [int (packedFieldTag info)] $ do'+        [ y <-- isolatedLengthy (parsePackedField info+                                    @@ repeatedFieldMVectors x Map.! fieldId f)+        , stmt $ loop x { repeatedFieldMVectors =+                                Map.insert (fieldId f) y+                                    $ repeatedFieldMVectors x }+        ]+    mapCase entryInfo = match [int (fieldTag info)] $ do'+        [ strictP (entry `sigP` var (unqual $ mapEntryTypeName entryInfo))+                <-- parseField info+        , stmt . let' [ valBind "key"+                            $ view' @@ fieldOf (keyField entryInfo)+                                    @@ entry+                      , valBind "value"+                            $ view' @@ fieldOf (valueField entryInfo)+                                    @@ entry+                      ]+               . loop+               . updateParseState+                    (overField info+                                (var "Data.Map.insert" @@ var "key" @@ var "value"))+               $ x+        ]++unknownFieldCase ::+    MessageInfo OccNameStr -> (ParseState HsExpr' -> HsExpr') -> ParseState HsExpr' -> RawMatch+{-+  wire -> do+        !y <- parseTaggedValueFromWire wire+        -- Omitted if not a group:+        case y of+            TaggedValue utag EndGroup+                -> fail ("Mismatched group-end tag number " ++ show utag)+            _ -> return ()+        loop (over unknownFields (\!t -> y:t) x) ...+-}+unknownFieldCase info loop x = match [wire] $ do' $+    [ strictP y <-- var "Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire" @@ wire+    ]+    +++    [ stmt $ case' y+        [ match+            [conP "Data.ProtoLens.Encoding.Wire.TaggedValue"+                [utag, conP_ "Data.ProtoLens.Encoding.Wire.EndGroup"]]+            $ var "Prelude.fail" @@+                (var "Prelude.++"+                    @@ string "Mismatched group-end tag number "+                    @@ (var "Prelude.show" @@ utag))+        , match [wildP] $ var "Prelude.return" @@ unit+        ]+    | Just _ <- [groupFieldNumber info]+    ]+    +++    [ stmt . loop . updateParseState (over' unknownFields' (cons @@ y))+        $ x+    ]+  where+    wire = bvar "wire"+    y = bvar "y"+    utag = bvar "utag"++-- | An expression of type "b -> a -> a", corresponding to a Lens a b+-- for this field.+setField :: FieldInfo -> HsExpr'+setField f = var "Lens.Family2.set" @@ fieldOf f++-- | An expression of type "(b -> b) -> a -> a", corresponding to a+-- Lens a b for this field.+overField :: FieldInfo -> HsExpr' -> HsExpr'+overField f = over' (fieldOf f)++-- | An expression of type "(b -> b) -> a -> a".+--+-- Specifically, this renders to:+--   over f (\!z -> g z) x+-- The extra strictness prevents a space leak due to lists being lazy.+over' :: HsExpr' -> HsExpr' -> HsExpr'+over' f g = var "Lens.Family2.over"+                @@ f+                @@ lambda [strictP t] (g @@ t)+  where+    t = bvar "t"++-- | A "Growing v RealWorld a -> Parser (Growing v RealWorld a)"+-- for a field that can be packed.+parsePackedField :: FieldInfo -> HsExpr'+{- let ploop qs = do+                    packedEnd <- atEnd+                    if packedEnd+                        then return qs+                        else do+                            !q <- {PARSE FIELD}+                            qs' <- append qs q+                            ploop qs'+   in ploop+-}+parsePackedField info = let' [funBind ploop $ match [qs] ploopExp]+                            (var ploop)+  where+    ploop = "ploop"+    q = bvar "q"+    qs = bvar "qs"+    qs' = bvar "qs'"+    packedEnd = bvar "packedEnd"+    ploopExp = do'+        [ packedEnd <-- var "Data.ProtoLens.Encoding.Bytes.atEnd"+        , stmt $+            if' packedEnd+                (var "Prelude.return" @@ qs)+                $ do'+                    [ strictP q <-- parseField info+                    , qs' <-- unsafeLiftIO' @@+                                (var "Data.ProtoLens.Encoding.Growing.append"+                                    @@ qs @@ q)+                    , stmt $ var ploop @@ qs'+                    ]+        ]++generatedBuilder :: MessageInfo OccNameStr -> HsExpr'+generatedBuilder m =+    lambda [x] $ foldMapExp $ map (buildPlainField x) (messageFields m)+                                ++ map (buildOneofField x) (messageOneofFields m)+                            ++ [buildUnknown x]+                            ++ buildGroupEnd+  where+    x = bvar "_x" -- TODO: rename to "x" once it's always used+    -- If this is a group, finish by emitting the end-group tag.+    buildGroupEnd = [ putVarInt' @@ int (groupEndTag g)+               | Just g <- [groupFieldNumber m]+               ]++buildUnknown :: HsExpr' -> HsExpr'+buildUnknown x+    = var "Data.ProtoLens.Encoding.Wire.buildFieldSet"+                @@ (view' @@ unknownFields' @@ x)++-- | Concatenate a list of Monoids into a single value.+-- For example, foldMapExp [a,b,c] will be transformed into+-- the (unrolled) expression a <> b <> c.+foldMapExp :: [HsExpr'] -> HsExpr'+foldMapExp [] = mempty'+foldMapExp [x] = x+foldMapExp (x:xs) = var "Data.Monoid.<>" @@ x @@ foldMapExp xs++-- | An expression of type @Builder@ which encodes the field value+-- @x@ based on the kind and type of the field @f@.+buildPlainField :: HsExpr' -> PlainFieldInfo -> HsExpr'+buildPlainField x f = case plainFieldKind f of+    RequiredField -> buildTaggedField info fieldValue+    OptionalMaybeField -> case' maybeFieldValue+                            [ match [conP_ "Prelude.Nothing"] mempty'+                            , match [conP "Prelude.Just" [v']]+                                $ buildTaggedField info v'+                            ]+    OptionalValueField -> let' [valBind v $ fieldValue]+                          $ if' (var "Prelude.==" @@ v' @@ var "Data.ProtoLens.fieldDefault")+                                mempty'+                                (buildTaggedField info v')+    MapField entryInfo+        -> var "Data.Monoid.mconcat"+            @@ (var "Prelude.map"+                    @@ lambda [v'] (buildEntry entryInfo v')+                    @@ (var "Data.Map.toList" @@ fieldValue))+    RepeatedField Packed -> buildPackedField info vectorFieldValue+    RepeatedField _ -> var "Data.ProtoLens.Encoding.Bytes.foldMapBuilder"+                            @@ lambda [v']+                                    (buildTaggedField info v')+                            @@ vectorFieldValue+  where+    info = plainFieldInfo f+    v = "_v"+    v' = bvar v+    fieldValue = view'+                    @@ fieldOf info+                    @@ x+    maybeFieldValue = view'+                        @@ fieldOfMaybe info+                        @@ x+    vectorFieldValue = view'+                        @@ fieldOfVector info+                        @@ x+    {- Builds a value of the given map entry type+       from the given key/value pair kv.++       ... set (fieldOf {KEY}) (fst kv)+            (set (fieldOf {VALUE}) (snd kv)+                (defMessage :: Foo'Entry)+    -}+    buildEntry entry kv+        = buildTaggedField info+            $ set'+                @@ fieldOf (keyField entry)+                @@ (var "Prelude.fst" @@ kv)+                @@ (set' @@ fieldOf (valueField entry)+                         @@ (var "Prelude.snd" @@ kv)+                         @@ (var "Data.ProtoLens.defMessage"+                                @::@ var (unqual $ mapEntryTypeName entry)))++fieldOf :: FieldInfo -> HsExpr'+fieldOf = fieldOfExp . overloadedFieldName++fieldOfMaybe :: FieldInfo -> HsExpr'+fieldOfMaybe = fieldOfExp . ("maybe'" <>) . overloadedFieldName++fieldOfOneof :: OneofInfo -> HsExpr'+fieldOfOneof =+    fieldOfExp . ("maybe'" <>) . overloadedName . oneofFieldName++fieldOfVector :: FieldInfo -> HsExpr'+fieldOfVector = fieldOfExp . ("vec'" <>) . overloadedFieldName++-- | Build a field along with its tag.+buildTaggedField :: FieldInfo -> HsExpr' -> HsExpr'+buildTaggedField f x = foldMapExp+    [ putVarInt' @@ int (fieldTag f)+    , buildField f @@ x+    ]++-- | Encodes a packed field as a byte string, along with+-- its wire type+number.+buildPackedField :: FieldInfo -> HsExpr' -> HsExpr'+{-+    let p = x -- where x might be a complicated expression+    in if null p then mempty+    else putVarInt {TAG}+            <> ... (runBuilder (mconcat (map {BUILD_ELT} p)))+-}+buildPackedField f x = let' [valBind p x]+    $ if' (var "Data.Vector.Generic.null" @@ var p) mempty'+    $ var "Data.Monoid.<>"+        @@ (putVarInt' @@ int (packedFieldTag f))+        @@ (buildFieldType lengthy+                @@ (var "Data.ProtoLens.Encoding.Bytes.runBuilder"+                    @@ (var "Data.ProtoLens.Encoding.Bytes.foldMapBuilder"+                            @@ buildField f+                            @@ var p)))+  where+    p = "p"++buildOneofField :: HsExpr' -> OneofInfo -> HsExpr'+buildOneofField x info = case' (view' @@ fieldOfOneof info @@ x) $+    (match [conP_ "Prelude.Nothing"] mempty')+    : [ match [conP "Prelude.Just" [conP (unqual $ caseConstructorName c)+                                 [v]]]+            $ buildTaggedField (caseField c) v+      | c <- oneofCases info+      ]+  where+    v = bvar "v"++-- | Compute the proto encoding's representation of the wire type+-- and field number.+--+-- The last three bits of the number store the wire type, and the+-- rest store the field number as a varint.+makeTag :: Int32 -> FieldEncoding -> Integer+makeTag num enc = fromIntegral $ joinTypeAndTag (fromIntegral num) (wireType enc)++fieldTag :: FieldInfo -> Integer+fieldTag f = makeTag (fieldDescriptor f ^. #number) $ fieldInfoEncoding f++packedFieldTag :: FieldInfo -> Integer+packedFieldTag f = makeTag (fieldDescriptor f ^. #number) lengthy++groupEndTag :: Int32 -> Integer+groupEndTag num = makeTag num groupEnd++-- | An expression that selects the overloaded field lens of this name.+--+-- field @"fieldName"+fieldOfExp :: Symbol -> HsExpr'+fieldOfExp sym = tyApp (var "Data.ProtoLens.Field.field") (promoteSymbol sym)++-- | Some functions that are used in multiple places in the generated code.+getVarInt', putVarInt', mempty', view', set', unknownFields', unsafeLiftIO'+    :: HsExpr'+getVarInt' = var "Data.ProtoLens.Encoding.Bytes.getVarInt"+putVarInt' = var "Data.ProtoLens.Encoding.Bytes.putVarInt"+mempty' = var "Data.Monoid.mempty"+view' = var "Lens.Family2.view"+set' = var "Lens.Family2.set"+unknownFields' = var "Data.ProtoLens.unknownFields"+unsafeLiftIO' = var "Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO"++-- | Returns an expression of type @Parser a@ for the given field.+parseField :: FieldInfo -> HsExpr'+parseField f = var "Data.ProtoLens.Encoding.Bytes.<?>"+                    @@ (parseFieldType $ fieldInfoEncoding f)+                    @@ string n+  where+    n = Text.unpack (fieldDescriptor f ^. #name)++-- | Returns a function corresponding to `a -> Builder`:+buildField :: FieldInfo -> HsExpr'+buildField = buildFieldType . fieldInfoEncoding++fieldInfoEncoding :: FieldInfo -> FieldEncoding+fieldInfoEncoding = fieldEncoding . view #type' . fieldDescriptor++growingType :: Env RdrNameStr -> FieldInfo -> HsType'+growingType env f+    = var "Data.ProtoLens.Encoding.Growing.Growing"+        @@ hsFieldVectorType f+        @@ var "Data.ProtoLens.Encoding.Growing.RealWorld"+        @@ hsFieldType env f

@@ -0,0 +1,261 @@+{-# LANGUAGE LambdaCase #-}+{-# LANGUAGE NoMonomorphismRestriction #-}+{-# LANGUAGE OverloadedLabels #-}+{-# LANGUAGE OverloadedStrings #-}+-- | This module generates the code for decoding and encoding+-- individual field types.+--+-- Upstream docs:+-- <https://developers.google.com/protocol-buffers/docs/encoding#structure>+module Data.ProtoLens.Compiler.Generate.Field+    ( hsFieldType+    , hsFieldVectorType+    , FieldEncoding(..)+    , fieldEncoding+    , lengthy+    , groupEnd+    , isolatedLengthy+    ) where++import Data.Text (unpack)+import Data.Word (Word8)+import Lens.Family2+import Proto.Google.Protobuf.Descriptor (FieldDescriptorProto'Type(..))++import Data.ProtoLens.Compiler.Definitions++import GHC.SourceGen++hsFieldType :: Env RdrNameStr -> FieldInfo -> HsType'+hsFieldType env f = let+    fd = fieldDescriptor f+    in var $ case fd ^. #type' of+        FieldDescriptorProto'TYPE_DOUBLE -> "Prelude.Double"+        FieldDescriptorProto'TYPE_FLOAT -> "Prelude.Float"+        FieldDescriptorProto'TYPE_INT64 -> "Data.Int.Int64"+        FieldDescriptorProto'TYPE_UINT64 -> "Data.Word.Word64"+        FieldDescriptorProto'TYPE_INT32 -> "Data.Int.Int32"+        FieldDescriptorProto'TYPE_FIXED64 -> "Data.Word.Word64"+        FieldDescriptorProto'TYPE_FIXED32 -> "Data.Word.Word32"+        FieldDescriptorProto'TYPE_BOOL -> "Prelude.Bool"+        FieldDescriptorProto'TYPE_STRING -> "Data.Text.Text"+        FieldDescriptorProto'TYPE_GROUP+            | Message m <- definedFieldType fd env -> messageName m+            | otherwise -> error $ "expected TYPE_GROUP for type name"+                                ++ unpack (fd ^. #typeName)+        FieldDescriptorProto'TYPE_MESSAGE+            | Message m <- definedFieldType fd env -> messageName m+            | otherwise -> error $ "expected TYPE_MESSAGE for type name"+                                ++ unpack (fd ^. #typeName)+        FieldDescriptorProto'TYPE_BYTES -> "Data.ByteString.ByteString"+        FieldDescriptorProto'TYPE_UINT32 -> "Data.Word.Word32"+        FieldDescriptorProto'TYPE_ENUM+            | Enum e <- definedFieldType fd env -> enumName e+            | otherwise -> error $ "expected TYPE_ENUM for type name"+                                ++ unpack (fd ^. #typeName)+        FieldDescriptorProto'TYPE_SFIXED32 -> "Data.Int.Int32"+        FieldDescriptorProto'TYPE_SFIXED64 -> "Data.Int.Int64"+        FieldDescriptorProto'TYPE_SINT32 -> "Data.Int.Int32"+        FieldDescriptorProto'TYPE_SINT64 -> "Data.Int.Int64"++hsFieldVectorType :: FieldInfo -> HsType'+hsFieldVectorType f = case fieldDescriptor f ^. #type' of+    FieldDescriptorProto'TYPE_MESSAGE -> boxed+    -- TODO: store enums in unboxed fields.+    FieldDescriptorProto'TYPE_ENUM -> boxed+    FieldDescriptorProto'TYPE_GROUP -> boxed+    FieldDescriptorProto'TYPE_STRING -> boxed+    FieldDescriptorProto'TYPE_BYTES -> boxed+    _ -> unboxed+  where+    boxed = var "Data.Vector.Vector"+    unboxed = var "Data.Vector.Unboxed.Vector"++-- | A representation for how to encode and decode a particular field type.+data FieldEncoding = FieldEncoding+    { buildFieldType :: HsExpr' -- ^ :: a -> Builder+    , parseFieldType :: HsExpr' -- ^ :: Parser a+    , wireType :: Word8+    }++-- | A variable-length integer, decoded as an unsigned Word64.+varint :: FieldEncoding+varint = FieldEncoding+            { wireType = 0+            , buildFieldType = putVarInt'+            , parseFieldType = getVarInt'+            }++-- | A fixed-length integer (Word64).+fixed64 :: FieldEncoding+fixed64 = FieldEncoding+            { wireType = 1+            , buildFieldType = var "Data.ProtoLens.Encoding.Bytes.putFixed64"+            , parseFieldType = var "Data.ProtoLens.Encoding.Bytes.getFixed64"+            }++-- | A fixed-length integer (Word32).+fixed32 :: FieldEncoding+fixed32 = FieldEncoding+            { wireType = 5+            , buildFieldType = var "Data.ProtoLens.Encoding.Bytes.putFixed32"+            , parseFieldType = var "Data.ProtoLens.Encoding.Bytes.getFixed32"+            }++-- | A ByteString, prefixed by its length (which is encoded as a varint).+lengthy :: FieldEncoding+lengthy = FieldEncoding+            { wireType = 2+            , buildFieldType = buildLengthy+            , parseFieldType = parseLengthy+            }+  where+    bs = bvar "bs"+    len = bvar "len"+    buildLengthy =+        -- Bind x since it may be a nontrivial expression:+        lambda [bs]+            $ var "Data.Monoid.<>"+                @@ (putVarInt'+                        @@ (fromIntegral'+                                @@ (var "Data.ByteString.length" @@ bs)))+                @@ (var "Data.ProtoLens.Encoding.Bytes.putBytes" @@ bs)+    parseLengthy = do'+        [ len <-- getVarInt'+        , stmt $ var "Data.ProtoLens.Encoding.Bytes.getBytes"+                    @@ (fromIntegral' @@ len)+        ]++group :: FieldEncoding+group = FieldEncoding+            { wireType = 3+            , buildFieldType = var "Data.ProtoLens.buildMessage"+            , parseFieldType = var "Data.ProtoLens.parseMessage"+            }++groupEnd :: FieldEncoding+groupEnd = FieldEncoding+            { wireType = 4+            , buildFieldType = var "Prelude.const" @@ var "Data.Monoid.mempty"+            , parseFieldType = var "Prelude.return" @@ unit+            }++-- Wrap a field encoding  with Haskell functions that should always succeed.+bijectField :: HsExpr' -> HsExpr' -> FieldEncoding -> FieldEncoding+bijectField buildF parseF f = FieldEncoding+    { buildFieldType = var "Prelude.." @@ buildFieldType f @@ buildF+    , parseFieldType = var "Prelude.fmap" @@ parseF @@ parseFieldType f+    , wireType = wireType f+    }++-- | Wrap a field encoding with Haskell functions that may fail during parsing.+partialField :: HsExpr' -> (HsExpr' -> HsExpr') -> FieldEncoding -> FieldEncoding+partialField buildF parseF f = FieldEncoding+    { buildFieldType = var "Prelude.." @@ buildFieldType f @@ buildF+    -- do+    --  value <- ...+    --  runEither $ {parseF} value+    , parseFieldType = do'+        [ value <-- parseFieldType f+        , stmt $ runEither @@ parseF value+        ]+    , wireType = wireType f+    }+  where+    value = bvar "value"+    runEither = var "Data.ProtoLens.Encoding.Bytes.runEither"++-- | Convert a field of one integral type to another.+integralField :: FieldEncoding -> FieldEncoding+integralField = bijectField fromIntegral' fromIntegral'++fieldEncoding :: FieldDescriptorProto'Type -> FieldEncoding+fieldEncoding = \case+    FieldDescriptorProto'TYPE_INT64 -> integralField varint+    FieldDescriptorProto'TYPE_UINT64 -> varint+    FieldDescriptorProto'TYPE_INT32 -> integralField varint+    FieldDescriptorProto'TYPE_UINT32 -> integralField varint+    FieldDescriptorProto'TYPE_FIXED64 -> fixed64+    FieldDescriptorProto'TYPE_FIXED32 -> fixed32+    FieldDescriptorProto'TYPE_SFIXED64 -> integralField fixed64+    FieldDescriptorProto'TYPE_SFIXED32 -> integralField fixed32+    FieldDescriptorProto'TYPE_DOUBLE ->+        bijectField+            (var "Data.ProtoLens.Encoding.Bytes.doubleToWord")+            (var "Data.ProtoLens.Encoding.Bytes.wordToDouble")+            fixed64+    FieldDescriptorProto'TYPE_FLOAT ->+        bijectField+            (var "Data.ProtoLens.Encoding.Bytes.floatToWord")+            (var "Data.ProtoLens.Encoding.Bytes.wordToFloat")+            fixed32+    FieldDescriptorProto'TYPE_BOOL ->+        bijectField+            (lambda [bvar "b"] $ if' (var "b") (int 1) (int 0))+            (var "Prelude./=" @@ int 0)+            varint+    FieldDescriptorProto'TYPE_ENUM ->+        -- TODO: don't throw an exception on unknown proto2 enums.+        bijectField (var "Prelude.fromEnum") (var "Prelude.toEnum")+            $ integralField varint+    FieldDescriptorProto'TYPE_SINT64 ->+        bijectField+            (var "Data.ProtoLens.Encoding.Bytes.signedInt64ToWord")+            (var "Data.ProtoLens.Encoding.Bytes.wordToSignedInt64")+            $ integralField varint+    FieldDescriptorProto'TYPE_SINT32 ->+        bijectField+            (var "Data.ProtoLens.Encoding.Bytes.signedInt32ToWord")+            (var "Data.ProtoLens.Encoding.Bytes.wordToSignedInt32")+            $ integralField varint+    FieldDescriptorProto'TYPE_BYTES -> lengthy+    FieldDescriptorProto'TYPE_STRING -> stringField+    FieldDescriptorProto'TYPE_MESSAGE -> message+    FieldDescriptorProto'TYPE_GROUP -> group++-- | A string, represented as Data.Text.Text.+stringField :: FieldEncoding+stringField = partialField (var "Data.Text.Encoding.encodeUtf8") decodeUtf8P lengthy+  where+    {- Translates to:+        case decodeUtf8' bytes of+            Left err -> Left (show err)+            Right r -> r+    Equivalently:+        first show $ decodeUtf8' bytes+    but avoids dragging in Data.Bifunctors.+    -}+    decodeUtf8P bytes =+        case' (var "Data.Text.Encoding.decodeUtf8'" @@ bytes)+            [ match ["Prelude.Left" `conP` [bvar "err"]]+                $ var "Prelude.Left" @@ (var "Prelude.show" @@ var "err")+            , match ["Prelude.Right" `conP` [bvar "r"]]+                $ var "Prelude.Right" @@ var "r"+            ]++-- | A protobuf message type.+message :: FieldEncoding+message = lengthy+        { buildFieldType = var "Prelude.." @@+            buildFieldType lengthy @@+            var "Data.ProtoLens.encodeMessage"+        , parseFieldType = isolatedLengthy (var "Data.ProtoLens.parseMessage")+        }++-- | Takes a @Parser a@, reads a varint and then runs the parser+-- isolated to the given length.+isolatedLengthy :: HsExpr' -> HsExpr'+isolatedLengthy parser = do'+    [ len <-- getVarInt'+    , stmt $ var "Data.ProtoLens.Encoding.Bytes.isolate"+                @@ (fromIntegral' @@ len)+                @@ parser+    ]+  where+    len = bvar "len"++-- | Some functions that are used in multiple places in the generated code.+getVarInt', putVarInt', fromIntegral' :: HsExpr'+getVarInt' = var "Data.ProtoLens.Encoding.Bytes.getVarInt"+putVarInt' = var "Data.ProtoLens.Encoding.Bytes.putVarInt"+fromIntegral' = var "Prelude.fromIntegral"

@@ -0,0 +1,105 @@+-- Copyright 2016 Google Inc. All Rights Reserved.+--+-- Use of this source code is governed by a BSD-style+-- license that can be found in the LICENSE file or at+-- https://developers.google.com/open-source/licenses/bsd+--+-- Code for writing protocol compiler plugins.++{-# LANGUAGE CPP #-}+{-# LANGUAGE OverloadedLabels #-}+{-# LANGUAGE OverloadedStrings #-}+module Data.ProtoLens.Compiler.Plugin+    ( ProtoFileName+    , ProtoFile(..)+    , analyzeProtoFiles+    , collectEnvFromDeps+    ) where++import Data.List (foldl')+import qualified Data.Map.Strict as Map+import Data.Map.Strict (Map, unions, (!))+import Data.String (fromString)+import qualified Data.Text as T+import Data.Text (Text)+import Lens.Family2+import Proto.Google.Protobuf.Descriptor (FileDescriptorProto)++import Data.ProtoLens.Compiler.Definitions+import Data.ProtoLens.Compiler.ModuleName++import GHC.SourceGen (ModuleNameStr, OccNameStr, RdrNameStr)++-- | The filename of an input .proto file.+type ProtoFileName = Text++data ProtoFile = ProtoFile+    { descriptor :: FileDescriptorProto+    , haskellModule :: ModuleNameStr+    , definitions :: Env OccNameStr+    , services :: [ServiceInfo]+    , exportedEnv :: Env RdrNameStr+    , publicImports :: [ModuleNameStr]+    }++-- Given a list of FileDescriptorProtos, collect information about each file+-- into a map of 'ProtoFile's keyed by 'ProtoFileName'.+analyzeProtoFiles :: [FileDescriptorProto] -> Map ProtoFileName ProtoFile+analyzeProtoFiles files =+    Map.fromList [ (f ^. #name, ingestFile f) | f <- files ]+  where+    filesByName = Map.fromList [(f ^. #name, f) | f <- files]+    moduleNames = fmap fdModuleName filesByName+    -- The definitions in each input proto file, indexed by filename.+    definitionsByName = fmap collectDefinitions filesByName+    servicesByName = fmap collectServices filesByName+    exportsByName = transitiveExports files+    exportedEnvs = fmap (foldMap (definitionsByName !)) exportsByName++    ingestFile f = ProtoFile+        { descriptor = f+        , haskellModule = m+        , definitions = definitionsByName ! n+        , services = servicesByName ! n+        , exportedEnv = qualifyEnv m $ exportedEnvs ! n+        , publicImports = [moduleNames ! i | i <- reexported]+        }+      where+        n = f ^. #name+        m = moduleNames ! n+        reexported =+            [ (f ^. #dependency) !! fromIntegral i+            | i <- f ^. #publicDependency+            ]++collectEnvFromDeps :: [ProtoFileName] -> Map ProtoFileName ProtoFile -> Env RdrNameStr+collectEnvFromDeps deps filesByName =+    unions $ fmap (exportedEnv . (filesByName !)) deps++-- | Get the Haskell 'ModuleName' corresponding to a given .proto file.+fdModuleName :: FileDescriptorProto -> ModuleNameStr+fdModuleName fd+      = fromString $ protoModuleName (T.unpack $ fd ^. #name)++-- | Given a list of .proto files (topologically sorted), determine which+-- files' definitions are exported by which files.+--+-- Files only export their own definitions, along with the definitions exported+-- by any "import public" declarations.  (And any definitions that *those* files+-- "import public", etc.)+transitiveExports :: [FileDescriptorProto] -> Map ProtoFileName [ProtoFileName]+-- Accumulate the transitive dependencies by folding over the files in+-- topological order.+transitiveExports = foldl' setExportsFromFile Map.empty+  where+    setExportsFromFile :: Map ProtoFileName [ProtoFileName]+                       -> FileDescriptorProto+                       -> Map ProtoFileName [ProtoFileName]+    setExportsFromFile prevExports fd+        = flip (Map.insert n) prevExports $+            n : concat [ prevExports ! ((fd ^. #dependency) !! fromIntegral i)+                       -- Note that publicDependency is a list of indices into+                       -- the dependency list.+                       | i <- fd ^. #publicDependency+                       ]+      where n = fd ^. #name

@@ -0,0 +1,1039 @@+{- This file was auto-generated from google/protobuf/compiler/plugin.proto by the proto-lens-protoc program. -}+{-# LANGUAGE ScopedTypeVariables, DataKinds, TypeFamilies, UndecidableInstances, GeneralizedNewtypeDeriving, MultiParamTypeClasses, FlexibleContexts, FlexibleInstances, PatternSynonyms, MagicHash, NoImplicitPrelude, DataKinds, BangPatterns, TypeApplications#-}+{-# OPTIONS_GHC -Wno-unused-imports#-}+{-# OPTIONS_GHC -Wno-duplicate-exports#-}+{-# OPTIONS_GHC -Wno-dodgy-exports#-}+module Proto.Google.Protobuf.Compiler.Plugin (+        CodeGeneratorRequest(), CodeGeneratorResponse(),+        CodeGeneratorResponse'File(), Version()+    ) where+import qualified Data.ProtoLens.Runtime.Control.DeepSeq as Control.DeepSeq+import qualified Data.ProtoLens.Runtime.Data.ProtoLens.Prism as Data.ProtoLens.Prism+import qualified Data.ProtoLens.Runtime.Prelude as Prelude+import qualified Data.ProtoLens.Runtime.Data.Int as Data.Int+import qualified Data.ProtoLens.Runtime.Data.Monoid as Data.Monoid+import qualified Data.ProtoLens.Runtime.Data.Word as Data.Word+import qualified Data.ProtoLens.Runtime.Data.ProtoLens as Data.ProtoLens+import qualified Data.ProtoLens.Runtime.Data.ProtoLens.Encoding.Bytes as Data.ProtoLens.Encoding.Bytes+import qualified Data.ProtoLens.Runtime.Data.ProtoLens.Encoding.Growing as Data.ProtoLens.Encoding.Growing+import qualified Data.ProtoLens.Runtime.Data.ProtoLens.Encoding.Parser.Unsafe as Data.ProtoLens.Encoding.Parser.Unsafe+import qualified Data.ProtoLens.Runtime.Data.ProtoLens.Encoding.Wire as Data.ProtoLens.Encoding.Wire+import qualified Data.ProtoLens.Runtime.Data.ProtoLens.Field as Data.ProtoLens.Field+import qualified Data.ProtoLens.Runtime.Data.ProtoLens.Message.Enum as Data.ProtoLens.Message.Enum+import qualified Data.ProtoLens.Runtime.Data.ProtoLens.Service.Types as Data.ProtoLens.Service.Types+import qualified Data.ProtoLens.Runtime.Lens.Family2 as Lens.Family2+import qualified Data.ProtoLens.Runtime.Lens.Family2.Unchecked as Lens.Family2.Unchecked+import qualified Data.ProtoLens.Runtime.Data.Text as Data.Text+import qualified Data.ProtoLens.Runtime.Data.Map as Data.Map+import qualified Data.ProtoLens.Runtime.Data.ByteString as Data.ByteString+import qualified Data.ProtoLens.Runtime.Data.ByteString.Char8 as Data.ByteString.Char8+import qualified Data.ProtoLens.Runtime.Data.Text.Encoding as Data.Text.Encoding+import qualified Data.ProtoLens.Runtime.Data.Vector as Data.Vector+import qualified Data.ProtoLens.Runtime.Data.Vector.Generic as Data.Vector.Generic+import qualified Data.ProtoLens.Runtime.Data.Vector.Unboxed as Data.Vector.Unboxed+import qualified Data.ProtoLens.Runtime.Text.Read as Text.Read+import qualified Proto.Google.Protobuf.Descriptor+{- | Fields :+     +         * 'Proto.Google.Protobuf.Compiler.Plugin_Fields.fileToGenerate' @:: Lens' CodeGeneratorRequest [Data.Text.Text]@+         * 'Proto.Google.Protobuf.Compiler.Plugin_Fields.vec'fileToGenerate' @:: Lens' CodeGeneratorRequest (Data.Vector.Vector Data.Text.Text)@+         * 'Proto.Google.Protobuf.Compiler.Plugin_Fields.parameter' @:: Lens' CodeGeneratorRequest Data.Text.Text@+         * 'Proto.Google.Protobuf.Compiler.Plugin_Fields.maybe'parameter' @:: Lens' CodeGeneratorRequest (Prelude.Maybe Data.Text.Text)@+         * 'Proto.Google.Protobuf.Compiler.Plugin_Fields.protoFile' @:: Lens' CodeGeneratorRequest [Proto.Google.Protobuf.Descriptor.FileDescriptorProto]@+         * 'Proto.Google.Protobuf.Compiler.Plugin_Fields.vec'protoFile' @:: Lens' CodeGeneratorRequest (Data.Vector.Vector Proto.Google.Protobuf.Descriptor.FileDescriptorProto)@+         * 'Proto.Google.Protobuf.Compiler.Plugin_Fields.compilerVersion' @:: Lens' CodeGeneratorRequest Version@+         * 'Proto.Google.Protobuf.Compiler.Plugin_Fields.maybe'compilerVersion' @:: Lens' CodeGeneratorRequest (Prelude.Maybe Version)@ -}+data CodeGeneratorRequest+  = CodeGeneratorRequest'_constructor {_CodeGeneratorRequest'fileToGenerate :: !(Data.Vector.Vector Data.Text.Text),+                                       _CodeGeneratorRequest'parameter :: !(Prelude.Maybe Data.Text.Text),+                                       _CodeGeneratorRequest'protoFile :: !(Data.Vector.Vector Proto.Google.Protobuf.Descriptor.FileDescriptorProto),+                                       _CodeGeneratorRequest'compilerVersion :: !(Prelude.Maybe Version),+                                       _CodeGeneratorRequest'_unknownFields :: !Data.ProtoLens.FieldSet}+  deriving (Prelude.Eq, Prelude.Ord)+instance Prelude.Show CodeGeneratorRequest where+  showsPrec _ __x __s+    = Prelude.showChar+        '{'+        (Prelude.showString+           (Data.ProtoLens.showMessageShort __x) (Prelude.showChar '}' __s))+instance Data.ProtoLens.Field.HasField CodeGeneratorRequest "fileToGenerate" [Data.Text.Text] where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _CodeGeneratorRequest'fileToGenerate+           (\ x__ y__ -> x__ {_CodeGeneratorRequest'fileToGenerate = y__}))+        (Lens.Family2.Unchecked.lens+           Data.Vector.Generic.toList+           (\ _ y__ -> Data.Vector.Generic.fromList y__))+instance Data.ProtoLens.Field.HasField CodeGeneratorRequest "vec'fileToGenerate" (Data.Vector.Vector Data.Text.Text) where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _CodeGeneratorRequest'fileToGenerate+           (\ x__ y__ -> x__ {_CodeGeneratorRequest'fileToGenerate = y__}))+        Prelude.id+instance Data.ProtoLens.Field.HasField CodeGeneratorRequest "parameter" Data.Text.Text where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _CodeGeneratorRequest'parameter+           (\ x__ y__ -> x__ {_CodeGeneratorRequest'parameter = y__}))+        (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault)+instance Data.ProtoLens.Field.HasField CodeGeneratorRequest "maybe'parameter" (Prelude.Maybe Data.Text.Text) where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _CodeGeneratorRequest'parameter+           (\ x__ y__ -> x__ {_CodeGeneratorRequest'parameter = y__}))+        Prelude.id+instance Data.ProtoLens.Field.HasField CodeGeneratorRequest "protoFile" [Proto.Google.Protobuf.Descriptor.FileDescriptorProto] where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _CodeGeneratorRequest'protoFile+           (\ x__ y__ -> x__ {_CodeGeneratorRequest'protoFile = y__}))+        (Lens.Family2.Unchecked.lens+           Data.Vector.Generic.toList+           (\ _ y__ -> Data.Vector.Generic.fromList y__))+instance Data.ProtoLens.Field.HasField CodeGeneratorRequest "vec'protoFile" (Data.Vector.Vector Proto.Google.Protobuf.Descriptor.FileDescriptorProto) where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _CodeGeneratorRequest'protoFile+           (\ x__ y__ -> x__ {_CodeGeneratorRequest'protoFile = y__}))+        Prelude.id+instance Data.ProtoLens.Field.HasField CodeGeneratorRequest "compilerVersion" Version where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _CodeGeneratorRequest'compilerVersion+           (\ x__ y__ -> x__ {_CodeGeneratorRequest'compilerVersion = y__}))+        (Data.ProtoLens.maybeLens Data.ProtoLens.defMessage)+instance Data.ProtoLens.Field.HasField CodeGeneratorRequest "maybe'compilerVersion" (Prelude.Maybe Version) where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _CodeGeneratorRequest'compilerVersion+           (\ x__ y__ -> x__ {_CodeGeneratorRequest'compilerVersion = y__}))+        Prelude.id+instance Data.ProtoLens.Message CodeGeneratorRequest where+  messageName _+    = Data.Text.pack "google.protobuf.compiler.CodeGeneratorRequest"+  fieldsByTag+    = let+        fileToGenerate__field_descriptor+          = Data.ProtoLens.FieldDescriptor+              "file_to_generate"+              (Data.ProtoLens.ScalarField Data.ProtoLens.StringField ::+                 Data.ProtoLens.FieldTypeDescriptor Data.Text.Text)+              (Data.ProtoLens.RepeatedField+                 Data.ProtoLens.Unpacked+                 (Data.ProtoLens.Field.field @"fileToGenerate")) ::+              Data.ProtoLens.FieldDescriptor CodeGeneratorRequest+        parameter__field_descriptor+          = Data.ProtoLens.FieldDescriptor+              "parameter"+              (Data.ProtoLens.ScalarField Data.ProtoLens.StringField ::+                 Data.ProtoLens.FieldTypeDescriptor Data.Text.Text)+              (Data.ProtoLens.OptionalField+                 (Data.ProtoLens.Field.field @"maybe'parameter")) ::+              Data.ProtoLens.FieldDescriptor CodeGeneratorRequest+        protoFile__field_descriptor+          = Data.ProtoLens.FieldDescriptor+              "proto_file"+              (Data.ProtoLens.MessageField Data.ProtoLens.MessageType ::+                 Data.ProtoLens.FieldTypeDescriptor Proto.Google.Protobuf.Descriptor.FileDescriptorProto)+              (Data.ProtoLens.RepeatedField+                 Data.ProtoLens.Unpacked+                 (Data.ProtoLens.Field.field @"protoFile")) ::+              Data.ProtoLens.FieldDescriptor CodeGeneratorRequest+        compilerVersion__field_descriptor+          = Data.ProtoLens.FieldDescriptor+              "compiler_version"+              (Data.ProtoLens.MessageField Data.ProtoLens.MessageType ::+                 Data.ProtoLens.FieldTypeDescriptor Version)+              (Data.ProtoLens.OptionalField+                 (Data.ProtoLens.Field.field @"maybe'compilerVersion")) ::+              Data.ProtoLens.FieldDescriptor CodeGeneratorRequest+      in+        Data.Map.fromList+          [(Data.ProtoLens.Tag 1, fileToGenerate__field_descriptor),+           (Data.ProtoLens.Tag 2, parameter__field_descriptor),+           (Data.ProtoLens.Tag 15, protoFile__field_descriptor),+           (Data.ProtoLens.Tag 3, compilerVersion__field_descriptor)]+  unknownFields+    = Lens.Family2.Unchecked.lens+        _CodeGeneratorRequest'_unknownFields+        (\ x__ y__ -> x__ {_CodeGeneratorRequest'_unknownFields = y__})+  defMessage+    = CodeGeneratorRequest'_constructor+        {_CodeGeneratorRequest'fileToGenerate = Data.Vector.Generic.empty,+         _CodeGeneratorRequest'parameter = Prelude.Nothing,+         _CodeGeneratorRequest'protoFile = Data.Vector.Generic.empty,+         _CodeGeneratorRequest'compilerVersion = Prelude.Nothing,+         _CodeGeneratorRequest'_unknownFields = []}+  parseMessage+    = let+        loop ::+          CodeGeneratorRequest+          -> Data.ProtoLens.Encoding.Growing.Growing Data.Vector.Vector Data.ProtoLens.Encoding.Growing.RealWorld Data.Text.Text+             -> Data.ProtoLens.Encoding.Growing.Growing Data.Vector.Vector Data.ProtoLens.Encoding.Growing.RealWorld Proto.Google.Protobuf.Descriptor.FileDescriptorProto+                -> Data.ProtoLens.Encoding.Bytes.Parser CodeGeneratorRequest+        loop x mutable'fileToGenerate mutable'protoFile+          = do end <- Data.ProtoLens.Encoding.Bytes.atEnd+               if end then+                   do frozen'fileToGenerate <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO+                                                 (Data.ProtoLens.Encoding.Growing.unsafeFreeze+                                                    mutable'fileToGenerate)+                      frozen'protoFile <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO+                                            (Data.ProtoLens.Encoding.Growing.unsafeFreeze+                                               mutable'protoFile)+                      (let missing = []+                       in+                         if Prelude.null missing then+                             Prelude.return ()+                         else+                             Prelude.fail+                               ((Prelude.++)+                                  "Missing required fields: "+                                  (Prelude.show (missing :: [Prelude.String]))))+                      Prelude.return+                        (Lens.Family2.over+                           Data.ProtoLens.unknownFields+                           (\ !t -> Prelude.reverse t)+                           (Lens.Family2.set+                              (Data.ProtoLens.Field.field @"vec'fileToGenerate")+                              frozen'fileToGenerate+                              (Lens.Family2.set+                                 (Data.ProtoLens.Field.field @"vec'protoFile") frozen'protoFile x)))+               else+                   do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt+                      case tag of+                        10+                          -> do !y <- (Data.ProtoLens.Encoding.Bytes.<?>)+                                        (do value <- do len <- Data.ProtoLens.Encoding.Bytes.getVarInt+                                                        Data.ProtoLens.Encoding.Bytes.getBytes+                                                          (Prelude.fromIntegral len)+                                            Data.ProtoLens.Encoding.Bytes.runEither+                                              (case Data.Text.Encoding.decodeUtf8' value of+                                                 (Prelude.Left err)+                                                   -> Prelude.Left (Prelude.show err)+                                                 (Prelude.Right r) -> Prelude.Right r))+                                        "file_to_generate"+                                v <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO+                                       (Data.ProtoLens.Encoding.Growing.append+                                          mutable'fileToGenerate y)+                                loop x v mutable'protoFile+                        18+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)+                                       (do value <- do len <- Data.ProtoLens.Encoding.Bytes.getVarInt+                                                       Data.ProtoLens.Encoding.Bytes.getBytes+                                                         (Prelude.fromIntegral len)+                                           Data.ProtoLens.Encoding.Bytes.runEither+                                             (case Data.Text.Encoding.decodeUtf8' value of+                                                (Prelude.Left err)+                                                  -> Prelude.Left (Prelude.show err)+                                                (Prelude.Right r) -> Prelude.Right r))+                                       "parameter"+                                loop+                                  (Lens.Family2.set (Data.ProtoLens.Field.field @"parameter") y x)+                                  mutable'fileToGenerate+                                  mutable'protoFile+                        122+                          -> do !y <- (Data.ProtoLens.Encoding.Bytes.<?>)+                                        (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt+                                            Data.ProtoLens.Encoding.Bytes.isolate+                                              (Prelude.fromIntegral len)+                                              Data.ProtoLens.parseMessage)+                                        "proto_file"+                                v <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO+                                       (Data.ProtoLens.Encoding.Growing.append mutable'protoFile y)+                                loop x mutable'fileToGenerate v+                        26+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)+                                       (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt+                                           Data.ProtoLens.Encoding.Bytes.isolate+                                             (Prelude.fromIntegral len) Data.ProtoLens.parseMessage)+                                       "compiler_version"+                                loop+                                  (Lens.Family2.set+                                     (Data.ProtoLens.Field.field @"compilerVersion") y x)+                                  mutable'fileToGenerate+                                  mutable'protoFile+                        wire+                          -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire+                                        wire+                                loop+                                  (Lens.Family2.over+                                     Data.ProtoLens.unknownFields (\ !t -> (:) y t) x)+                                  mutable'fileToGenerate+                                  mutable'protoFile+      in+        (Data.ProtoLens.Encoding.Bytes.<?>)+          (do mutable'fileToGenerate <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO+                                          Data.ProtoLens.Encoding.Growing.new+              mutable'protoFile <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO+                                     Data.ProtoLens.Encoding.Growing.new+              loop+                Data.ProtoLens.defMessage mutable'fileToGenerate mutable'protoFile)+          "CodeGeneratorRequest"+  buildMessage+    = \ _x+        -> (Data.Monoid.<>)+             (Data.ProtoLens.Encoding.Bytes.foldMapBuilder+                (\ _v+                   -> (Data.Monoid.<>)+                        (Data.ProtoLens.Encoding.Bytes.putVarInt 10)+                        ((Prelude..)+                           (\ bs+                              -> (Data.Monoid.<>)+                                   (Data.ProtoLens.Encoding.Bytes.putVarInt+                                      (Prelude.fromIntegral (Data.ByteString.length bs)))+                                   (Data.ProtoLens.Encoding.Bytes.putBytes bs))+                           Data.Text.Encoding.encodeUtf8+                           _v))+                (Lens.Family2.view+                   (Data.ProtoLens.Field.field @"vec'fileToGenerate") _x))+             ((Data.Monoid.<>)+                (case+                     Lens.Family2.view+                       (Data.ProtoLens.Field.field @"maybe'parameter") _x+                 of+                   Prelude.Nothing -> Data.Monoid.mempty+                   (Prelude.Just _v)+                     -> (Data.Monoid.<>)+                          (Data.ProtoLens.Encoding.Bytes.putVarInt 18)+                          ((Prelude..)+                             (\ bs+                                -> (Data.Monoid.<>)+                                     (Data.ProtoLens.Encoding.Bytes.putVarInt+                                        (Prelude.fromIntegral (Data.ByteString.length bs)))+                                     (Data.ProtoLens.Encoding.Bytes.putBytes bs))+                             Data.Text.Encoding.encodeUtf8+                             _v))+                ((Data.Monoid.<>)+                   (Data.ProtoLens.Encoding.Bytes.foldMapBuilder+                      (\ _v+                         -> (Data.Monoid.<>)+                              (Data.ProtoLens.Encoding.Bytes.putVarInt 122)+                              ((Prelude..)+                                 (\ bs+                                    -> (Data.Monoid.<>)+                                         (Data.ProtoLens.Encoding.Bytes.putVarInt+                                            (Prelude.fromIntegral (Data.ByteString.length bs)))+                                         (Data.ProtoLens.Encoding.Bytes.putBytes bs))+                                 Data.ProtoLens.encodeMessage+                                 _v))+                      (Lens.Family2.view+                         (Data.ProtoLens.Field.field @"vec'protoFile") _x))+                   ((Data.Monoid.<>)+                      (case+                           Lens.Family2.view+                             (Data.ProtoLens.Field.field @"maybe'compilerVersion") _x+                       of+                         Prelude.Nothing -> Data.Monoid.mempty+                         (Prelude.Just _v)+                           -> (Data.Monoid.<>)+                                (Data.ProtoLens.Encoding.Bytes.putVarInt 26)+                                ((Prelude..)+                                   (\ bs+                                      -> (Data.Monoid.<>)+                                           (Data.ProtoLens.Encoding.Bytes.putVarInt+                                              (Prelude.fromIntegral (Data.ByteString.length bs)))+                                           (Data.ProtoLens.Encoding.Bytes.putBytes bs))+                                   Data.ProtoLens.encodeMessage+                                   _v))+                      (Data.ProtoLens.Encoding.Wire.buildFieldSet+                         (Lens.Family2.view Data.ProtoLens.unknownFields _x)))))+instance Control.DeepSeq.NFData CodeGeneratorRequest where+  rnf+    = \ x__+        -> Control.DeepSeq.deepseq+             (_CodeGeneratorRequest'_unknownFields x__)+             (Control.DeepSeq.deepseq+                (_CodeGeneratorRequest'fileToGenerate x__)+                (Control.DeepSeq.deepseq+                   (_CodeGeneratorRequest'parameter x__)+                   (Control.DeepSeq.deepseq+                      (_CodeGeneratorRequest'protoFile x__)+                      (Control.DeepSeq.deepseq+                         (_CodeGeneratorRequest'compilerVersion x__) ()))))+{- | Fields :+     +         * 'Proto.Google.Protobuf.Compiler.Plugin_Fields.error' @:: Lens' CodeGeneratorResponse Data.Text.Text@+         * 'Proto.Google.Protobuf.Compiler.Plugin_Fields.maybe'error' @:: Lens' CodeGeneratorResponse (Prelude.Maybe Data.Text.Text)@+         * 'Proto.Google.Protobuf.Compiler.Plugin_Fields.file' @:: Lens' CodeGeneratorResponse [CodeGeneratorResponse'File]@+         * 'Proto.Google.Protobuf.Compiler.Plugin_Fields.vec'file' @:: Lens' CodeGeneratorResponse (Data.Vector.Vector CodeGeneratorResponse'File)@ -}+data CodeGeneratorResponse+  = CodeGeneratorResponse'_constructor {_CodeGeneratorResponse'error :: !(Prelude.Maybe Data.Text.Text),+                                        _CodeGeneratorResponse'file :: !(Data.Vector.Vector CodeGeneratorResponse'File),+                                        _CodeGeneratorResponse'_unknownFields :: !Data.ProtoLens.FieldSet}+  deriving (Prelude.Eq, Prelude.Ord)+instance Prelude.Show CodeGeneratorResponse where+  showsPrec _ __x __s+    = Prelude.showChar+        '{'+        (Prelude.showString+           (Data.ProtoLens.showMessageShort __x) (Prelude.showChar '}' __s))+instance Data.ProtoLens.Field.HasField CodeGeneratorResponse "error" Data.Text.Text where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _CodeGeneratorResponse'error+           (\ x__ y__ -> x__ {_CodeGeneratorResponse'error = y__}))+        (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault)+instance Data.ProtoLens.Field.HasField CodeGeneratorResponse "maybe'error" (Prelude.Maybe Data.Text.Text) where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _CodeGeneratorResponse'error+           (\ x__ y__ -> x__ {_CodeGeneratorResponse'error = y__}))+        Prelude.id+instance Data.ProtoLens.Field.HasField CodeGeneratorResponse "file" [CodeGeneratorResponse'File] where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _CodeGeneratorResponse'file+           (\ x__ y__ -> x__ {_CodeGeneratorResponse'file = y__}))+        (Lens.Family2.Unchecked.lens+           Data.Vector.Generic.toList+           (\ _ y__ -> Data.Vector.Generic.fromList y__))+instance Data.ProtoLens.Field.HasField CodeGeneratorResponse "vec'file" (Data.Vector.Vector CodeGeneratorResponse'File) where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _CodeGeneratorResponse'file+           (\ x__ y__ -> x__ {_CodeGeneratorResponse'file = y__}))+        Prelude.id+instance Data.ProtoLens.Message CodeGeneratorResponse where+  messageName _+    = Data.Text.pack "google.protobuf.compiler.CodeGeneratorResponse"+  fieldsByTag+    = let+        error__field_descriptor+          = Data.ProtoLens.FieldDescriptor+              "error"+              (Data.ProtoLens.ScalarField Data.ProtoLens.StringField ::+                 Data.ProtoLens.FieldTypeDescriptor Data.Text.Text)+              (Data.ProtoLens.OptionalField+                 (Data.ProtoLens.Field.field @"maybe'error")) ::+              Data.ProtoLens.FieldDescriptor CodeGeneratorResponse+        file__field_descriptor+          = Data.ProtoLens.FieldDescriptor+              "file"+              (Data.ProtoLens.MessageField Data.ProtoLens.MessageType ::+                 Data.ProtoLens.FieldTypeDescriptor CodeGeneratorResponse'File)+              (Data.ProtoLens.RepeatedField+                 Data.ProtoLens.Unpacked (Data.ProtoLens.Field.field @"file")) ::+              Data.ProtoLens.FieldDescriptor CodeGeneratorResponse+      in+        Data.Map.fromList+          [(Data.ProtoLens.Tag 1, error__field_descriptor),+           (Data.ProtoLens.Tag 15, file__field_descriptor)]+  unknownFields+    = Lens.Family2.Unchecked.lens+        _CodeGeneratorResponse'_unknownFields+        (\ x__ y__ -> x__ {_CodeGeneratorResponse'_unknownFields = y__})+  defMessage+    = CodeGeneratorResponse'_constructor+        {_CodeGeneratorResponse'error = Prelude.Nothing,+         _CodeGeneratorResponse'file = Data.Vector.Generic.empty,+         _CodeGeneratorResponse'_unknownFields = []}+  parseMessage+    = let+        loop ::+          CodeGeneratorResponse+          -> Data.ProtoLens.Encoding.Growing.Growing Data.Vector.Vector Data.ProtoLens.Encoding.Growing.RealWorld CodeGeneratorResponse'File+             -> Data.ProtoLens.Encoding.Bytes.Parser CodeGeneratorResponse+        loop x mutable'file+          = do end <- Data.ProtoLens.Encoding.Bytes.atEnd+               if end then+                   do frozen'file <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO+                                       (Data.ProtoLens.Encoding.Growing.unsafeFreeze mutable'file)+                      (let missing = []+                       in+                         if Prelude.null missing then+                             Prelude.return ()+                         else+                             Prelude.fail+                               ((Prelude.++)+                                  "Missing required fields: "+                                  (Prelude.show (missing :: [Prelude.String]))))+                      Prelude.return+                        (Lens.Family2.over+                           Data.ProtoLens.unknownFields+                           (\ !t -> Prelude.reverse t)+                           (Lens.Family2.set+                              (Data.ProtoLens.Field.field @"vec'file") frozen'file x))+               else+                   do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt+                      case tag of+                        10+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)+                                       (do value <- do len <- Data.ProtoLens.Encoding.Bytes.getVarInt+                                                       Data.ProtoLens.Encoding.Bytes.getBytes+                                                         (Prelude.fromIntegral len)+                                           Data.ProtoLens.Encoding.Bytes.runEither+                                             (case Data.Text.Encoding.decodeUtf8' value of+                                                (Prelude.Left err)+                                                  -> Prelude.Left (Prelude.show err)+                                                (Prelude.Right r) -> Prelude.Right r))+                                       "error"+                                loop+                                  (Lens.Family2.set (Data.ProtoLens.Field.field @"error") y x)+                                  mutable'file+                        122+                          -> do !y <- (Data.ProtoLens.Encoding.Bytes.<?>)+                                        (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt+                                            Data.ProtoLens.Encoding.Bytes.isolate+                                              (Prelude.fromIntegral len)+                                              Data.ProtoLens.parseMessage)+                                        "file"+                                v <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO+                                       (Data.ProtoLens.Encoding.Growing.append mutable'file y)+                                loop x v+                        wire+                          -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire+                                        wire+                                loop+                                  (Lens.Family2.over+                                     Data.ProtoLens.unknownFields (\ !t -> (:) y t) x)+                                  mutable'file+      in+        (Data.ProtoLens.Encoding.Bytes.<?>)+          (do mutable'file <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO+                                Data.ProtoLens.Encoding.Growing.new+              loop Data.ProtoLens.defMessage mutable'file)+          "CodeGeneratorResponse"+  buildMessage+    = \ _x+        -> (Data.Monoid.<>)+             (case+                  Lens.Family2.view (Data.ProtoLens.Field.field @"maybe'error") _x+              of+                Prelude.Nothing -> Data.Monoid.mempty+                (Prelude.Just _v)+                  -> (Data.Monoid.<>)+                       (Data.ProtoLens.Encoding.Bytes.putVarInt 10)+                       ((Prelude..)+                          (\ bs+                             -> (Data.Monoid.<>)+                                  (Data.ProtoLens.Encoding.Bytes.putVarInt+                                     (Prelude.fromIntegral (Data.ByteString.length bs)))+                                  (Data.ProtoLens.Encoding.Bytes.putBytes bs))+                          Data.Text.Encoding.encodeUtf8+                          _v))+             ((Data.Monoid.<>)+                (Data.ProtoLens.Encoding.Bytes.foldMapBuilder+                   (\ _v+                      -> (Data.Monoid.<>)+                           (Data.ProtoLens.Encoding.Bytes.putVarInt 122)+                           ((Prelude..)+                              (\ bs+                                 -> (Data.Monoid.<>)+                                      (Data.ProtoLens.Encoding.Bytes.putVarInt+                                         (Prelude.fromIntegral (Data.ByteString.length bs)))+                                      (Data.ProtoLens.Encoding.Bytes.putBytes bs))+                              Data.ProtoLens.encodeMessage+                              _v))+                   (Lens.Family2.view (Data.ProtoLens.Field.field @"vec'file") _x))+                (Data.ProtoLens.Encoding.Wire.buildFieldSet+                   (Lens.Family2.view Data.ProtoLens.unknownFields _x)))+instance Control.DeepSeq.NFData CodeGeneratorResponse where+  rnf+    = \ x__+        -> Control.DeepSeq.deepseq+             (_CodeGeneratorResponse'_unknownFields x__)+             (Control.DeepSeq.deepseq+                (_CodeGeneratorResponse'error x__)+                (Control.DeepSeq.deepseq (_CodeGeneratorResponse'file x__) ()))+{- | Fields :+     +         * 'Proto.Google.Protobuf.Compiler.Plugin_Fields.name' @:: Lens' CodeGeneratorResponse'File Data.Text.Text@+         * 'Proto.Google.Protobuf.Compiler.Plugin_Fields.maybe'name' @:: Lens' CodeGeneratorResponse'File (Prelude.Maybe Data.Text.Text)@+         * 'Proto.Google.Protobuf.Compiler.Plugin_Fields.insertionPoint' @:: Lens' CodeGeneratorResponse'File Data.Text.Text@+         * 'Proto.Google.Protobuf.Compiler.Plugin_Fields.maybe'insertionPoint' @:: Lens' CodeGeneratorResponse'File (Prelude.Maybe Data.Text.Text)@+         * 'Proto.Google.Protobuf.Compiler.Plugin_Fields.content' @:: Lens' CodeGeneratorResponse'File Data.Text.Text@+         * 'Proto.Google.Protobuf.Compiler.Plugin_Fields.maybe'content' @:: Lens' CodeGeneratorResponse'File (Prelude.Maybe Data.Text.Text)@ -}+data CodeGeneratorResponse'File+  = CodeGeneratorResponse'File'_constructor {_CodeGeneratorResponse'File'name :: !(Prelude.Maybe Data.Text.Text),+                                             _CodeGeneratorResponse'File'insertionPoint :: !(Prelude.Maybe Data.Text.Text),+                                             _CodeGeneratorResponse'File'content :: !(Prelude.Maybe Data.Text.Text),+                                             _CodeGeneratorResponse'File'_unknownFields :: !Data.ProtoLens.FieldSet}+  deriving (Prelude.Eq, Prelude.Ord)+instance Prelude.Show CodeGeneratorResponse'File where+  showsPrec _ __x __s+    = Prelude.showChar+        '{'+        (Prelude.showString+           (Data.ProtoLens.showMessageShort __x) (Prelude.showChar '}' __s))+instance Data.ProtoLens.Field.HasField CodeGeneratorResponse'File "name" Data.Text.Text where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _CodeGeneratorResponse'File'name+           (\ x__ y__ -> x__ {_CodeGeneratorResponse'File'name = y__}))+        (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault)+instance Data.ProtoLens.Field.HasField CodeGeneratorResponse'File "maybe'name" (Prelude.Maybe Data.Text.Text) where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _CodeGeneratorResponse'File'name+           (\ x__ y__ -> x__ {_CodeGeneratorResponse'File'name = y__}))+        Prelude.id+instance Data.ProtoLens.Field.HasField CodeGeneratorResponse'File "insertionPoint" Data.Text.Text where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _CodeGeneratorResponse'File'insertionPoint+           (\ x__ y__+              -> x__ {_CodeGeneratorResponse'File'insertionPoint = y__}))+        (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault)+instance Data.ProtoLens.Field.HasField CodeGeneratorResponse'File "maybe'insertionPoint" (Prelude.Maybe Data.Text.Text) where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _CodeGeneratorResponse'File'insertionPoint+           (\ x__ y__+              -> x__ {_CodeGeneratorResponse'File'insertionPoint = y__}))+        Prelude.id+instance Data.ProtoLens.Field.HasField CodeGeneratorResponse'File "content" Data.Text.Text where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _CodeGeneratorResponse'File'content+           (\ x__ y__ -> x__ {_CodeGeneratorResponse'File'content = y__}))+        (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault)+instance Data.ProtoLens.Field.HasField CodeGeneratorResponse'File "maybe'content" (Prelude.Maybe Data.Text.Text) where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _CodeGeneratorResponse'File'content+           (\ x__ y__ -> x__ {_CodeGeneratorResponse'File'content = y__}))+        Prelude.id+instance Data.ProtoLens.Message CodeGeneratorResponse'File where+  messageName _+    = Data.Text.pack+        "google.protobuf.compiler.CodeGeneratorResponse.File"+  fieldsByTag+    = let+        name__field_descriptor+          = Data.ProtoLens.FieldDescriptor+              "name"+              (Data.ProtoLens.ScalarField Data.ProtoLens.StringField ::+                 Data.ProtoLens.FieldTypeDescriptor Data.Text.Text)+              (Data.ProtoLens.OptionalField+                 (Data.ProtoLens.Field.field @"maybe'name")) ::+              Data.ProtoLens.FieldDescriptor CodeGeneratorResponse'File+        insertionPoint__field_descriptor+          = Data.ProtoLens.FieldDescriptor+              "insertion_point"+              (Data.ProtoLens.ScalarField Data.ProtoLens.StringField ::+                 Data.ProtoLens.FieldTypeDescriptor Data.Text.Text)+              (Data.ProtoLens.OptionalField+                 (Data.ProtoLens.Field.field @"maybe'insertionPoint")) ::+              Data.ProtoLens.FieldDescriptor CodeGeneratorResponse'File+        content__field_descriptor+          = Data.ProtoLens.FieldDescriptor+              "content"+              (Data.ProtoLens.ScalarField Data.ProtoLens.StringField ::+                 Data.ProtoLens.FieldTypeDescriptor Data.Text.Text)+              (Data.ProtoLens.OptionalField+                 (Data.ProtoLens.Field.field @"maybe'content")) ::+              Data.ProtoLens.FieldDescriptor CodeGeneratorResponse'File+      in+        Data.Map.fromList+          [(Data.ProtoLens.Tag 1, name__field_descriptor),+           (Data.ProtoLens.Tag 2, insertionPoint__field_descriptor),+           (Data.ProtoLens.Tag 15, content__field_descriptor)]+  unknownFields+    = Lens.Family2.Unchecked.lens+        _CodeGeneratorResponse'File'_unknownFields+        (\ x__ y__+           -> x__ {_CodeGeneratorResponse'File'_unknownFields = y__})+  defMessage+    = CodeGeneratorResponse'File'_constructor+        {_CodeGeneratorResponse'File'name = Prelude.Nothing,+         _CodeGeneratorResponse'File'insertionPoint = Prelude.Nothing,+         _CodeGeneratorResponse'File'content = Prelude.Nothing,+         _CodeGeneratorResponse'File'_unknownFields = []}+  parseMessage+    = let+        loop ::+          CodeGeneratorResponse'File+          -> Data.ProtoLens.Encoding.Bytes.Parser CodeGeneratorResponse'File+        loop x+          = do end <- Data.ProtoLens.Encoding.Bytes.atEnd+               if end then+                   do (let missing = []+                       in+                         if Prelude.null missing then+                             Prelude.return ()+                         else+                             Prelude.fail+                               ((Prelude.++)+                                  "Missing required fields: "+                                  (Prelude.show (missing :: [Prelude.String]))))+                      Prelude.return+                        (Lens.Family2.over+                           Data.ProtoLens.unknownFields (\ !t -> Prelude.reverse t) x)+               else+                   do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt+                      case tag of+                        10+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)+                                       (do value <- do len <- Data.ProtoLens.Encoding.Bytes.getVarInt+                                                       Data.ProtoLens.Encoding.Bytes.getBytes+                                                         (Prelude.fromIntegral len)+                                           Data.ProtoLens.Encoding.Bytes.runEither+                                             (case Data.Text.Encoding.decodeUtf8' value of+                                                (Prelude.Left err)+                                                  -> Prelude.Left (Prelude.show err)+                                                (Prelude.Right r) -> Prelude.Right r))+                                       "name"+                                loop (Lens.Family2.set (Data.ProtoLens.Field.field @"name") y x)+                        18+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)+                                       (do value <- do len <- Data.ProtoLens.Encoding.Bytes.getVarInt+                                                       Data.ProtoLens.Encoding.Bytes.getBytes+                                                         (Prelude.fromIntegral len)+                                           Data.ProtoLens.Encoding.Bytes.runEither+                                             (case Data.Text.Encoding.decodeUtf8' value of+                                                (Prelude.Left err)+                                                  -> Prelude.Left (Prelude.show err)+                                                (Prelude.Right r) -> Prelude.Right r))+                                       "insertion_point"+                                loop+                                  (Lens.Family2.set+                                     (Data.ProtoLens.Field.field @"insertionPoint") y x)+                        122+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)+                                       (do value <- do len <- Data.ProtoLens.Encoding.Bytes.getVarInt+                                                       Data.ProtoLens.Encoding.Bytes.getBytes+                                                         (Prelude.fromIntegral len)+                                           Data.ProtoLens.Encoding.Bytes.runEither+                                             (case Data.Text.Encoding.decodeUtf8' value of+                                                (Prelude.Left err)+                                                  -> Prelude.Left (Prelude.show err)+                                                (Prelude.Right r) -> Prelude.Right r))+                                       "content"+                                loop (Lens.Family2.set (Data.ProtoLens.Field.field @"content") y x)+                        wire+                          -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire+                                        wire+                                loop+                                  (Lens.Family2.over+                                     Data.ProtoLens.unknownFields (\ !t -> (:) y t) x)+      in+        (Data.ProtoLens.Encoding.Bytes.<?>)+          (do loop Data.ProtoLens.defMessage) "File"+  buildMessage+    = \ _x+        -> (Data.Monoid.<>)+             (case+                  Lens.Family2.view (Data.ProtoLens.Field.field @"maybe'name") _x+              of+                Prelude.Nothing -> Data.Monoid.mempty+                (Prelude.Just _v)+                  -> (Data.Monoid.<>)+                       (Data.ProtoLens.Encoding.Bytes.putVarInt 10)+                       ((Prelude..)+                          (\ bs+                             -> (Data.Monoid.<>)+                                  (Data.ProtoLens.Encoding.Bytes.putVarInt+                                     (Prelude.fromIntegral (Data.ByteString.length bs)))+                                  (Data.ProtoLens.Encoding.Bytes.putBytes bs))+                          Data.Text.Encoding.encodeUtf8+                          _v))+             ((Data.Monoid.<>)+                (case+                     Lens.Family2.view+                       (Data.ProtoLens.Field.field @"maybe'insertionPoint") _x+                 of+                   Prelude.Nothing -> Data.Monoid.mempty+                   (Prelude.Just _v)+                     -> (Data.Monoid.<>)+                          (Data.ProtoLens.Encoding.Bytes.putVarInt 18)+                          ((Prelude..)+                             (\ bs+                                -> (Data.Monoid.<>)+                                     (Data.ProtoLens.Encoding.Bytes.putVarInt+                                        (Prelude.fromIntegral (Data.ByteString.length bs)))+                                     (Data.ProtoLens.Encoding.Bytes.putBytes bs))+                             Data.Text.Encoding.encodeUtf8+                             _v))+                ((Data.Monoid.<>)+                   (case+                        Lens.Family2.view (Data.ProtoLens.Field.field @"maybe'content") _x+                    of+                      Prelude.Nothing -> Data.Monoid.mempty+                      (Prelude.Just _v)+                        -> (Data.Monoid.<>)+                             (Data.ProtoLens.Encoding.Bytes.putVarInt 122)+                             ((Prelude..)+                                (\ bs+                                   -> (Data.Monoid.<>)+                                        (Data.ProtoLens.Encoding.Bytes.putVarInt+                                           (Prelude.fromIntegral (Data.ByteString.length bs)))+                                        (Data.ProtoLens.Encoding.Bytes.putBytes bs))+                                Data.Text.Encoding.encodeUtf8+                                _v))+                   (Data.ProtoLens.Encoding.Wire.buildFieldSet+                      (Lens.Family2.view Data.ProtoLens.unknownFields _x))))+instance Control.DeepSeq.NFData CodeGeneratorResponse'File where+  rnf+    = \ x__+        -> Control.DeepSeq.deepseq+             (_CodeGeneratorResponse'File'_unknownFields x__)+             (Control.DeepSeq.deepseq+                (_CodeGeneratorResponse'File'name x__)+                (Control.DeepSeq.deepseq+                   (_CodeGeneratorResponse'File'insertionPoint x__)+                   (Control.DeepSeq.deepseq+                      (_CodeGeneratorResponse'File'content x__) ())))+{- | Fields :+     +         * 'Proto.Google.Protobuf.Compiler.Plugin_Fields.major' @:: Lens' Version Data.Int.Int32@+         * 'Proto.Google.Protobuf.Compiler.Plugin_Fields.maybe'major' @:: Lens' Version (Prelude.Maybe Data.Int.Int32)@+         * 'Proto.Google.Protobuf.Compiler.Plugin_Fields.minor' @:: Lens' Version Data.Int.Int32@+         * 'Proto.Google.Protobuf.Compiler.Plugin_Fields.maybe'minor' @:: Lens' Version (Prelude.Maybe Data.Int.Int32)@+         * 'Proto.Google.Protobuf.Compiler.Plugin_Fields.patch' @:: Lens' Version Data.Int.Int32@+         * 'Proto.Google.Protobuf.Compiler.Plugin_Fields.maybe'patch' @:: Lens' Version (Prelude.Maybe Data.Int.Int32)@+         * 'Proto.Google.Protobuf.Compiler.Plugin_Fields.suffix' @:: Lens' Version Data.Text.Text@+         * 'Proto.Google.Protobuf.Compiler.Plugin_Fields.maybe'suffix' @:: Lens' Version (Prelude.Maybe Data.Text.Text)@ -}+data Version+  = Version'_constructor {_Version'major :: !(Prelude.Maybe Data.Int.Int32),+                          _Version'minor :: !(Prelude.Maybe Data.Int.Int32),+                          _Version'patch :: !(Prelude.Maybe Data.Int.Int32),+                          _Version'suffix :: !(Prelude.Maybe Data.Text.Text),+                          _Version'_unknownFields :: !Data.ProtoLens.FieldSet}+  deriving (Prelude.Eq, Prelude.Ord)+instance Prelude.Show Version where+  showsPrec _ __x __s+    = Prelude.showChar+        '{'+        (Prelude.showString+           (Data.ProtoLens.showMessageShort __x) (Prelude.showChar '}' __s))+instance Data.ProtoLens.Field.HasField Version "major" Data.Int.Int32 where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _Version'major (\ x__ y__ -> x__ {_Version'major = y__}))+        (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault)+instance Data.ProtoLens.Field.HasField Version "maybe'major" (Prelude.Maybe Data.Int.Int32) where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _Version'major (\ x__ y__ -> x__ {_Version'major = y__}))+        Prelude.id+instance Data.ProtoLens.Field.HasField Version "minor" Data.Int.Int32 where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _Version'minor (\ x__ y__ -> x__ {_Version'minor = y__}))+        (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault)+instance Data.ProtoLens.Field.HasField Version "maybe'minor" (Prelude.Maybe Data.Int.Int32) where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _Version'minor (\ x__ y__ -> x__ {_Version'minor = y__}))+        Prelude.id+instance Data.ProtoLens.Field.HasField Version "patch" Data.Int.Int32 where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _Version'patch (\ x__ y__ -> x__ {_Version'patch = y__}))+        (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault)+instance Data.ProtoLens.Field.HasField Version "maybe'patch" (Prelude.Maybe Data.Int.Int32) where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _Version'patch (\ x__ y__ -> x__ {_Version'patch = y__}))+        Prelude.id+instance Data.ProtoLens.Field.HasField Version "suffix" Data.Text.Text where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _Version'suffix (\ x__ y__ -> x__ {_Version'suffix = y__}))+        (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault)+instance Data.ProtoLens.Field.HasField Version "maybe'suffix" (Prelude.Maybe Data.Text.Text) where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _Version'suffix (\ x__ y__ -> x__ {_Version'suffix = y__}))+        Prelude.id+instance Data.ProtoLens.Message Version where+  messageName _ = Data.Text.pack "google.protobuf.compiler.Version"+  fieldsByTag+    = let+        major__field_descriptor+          = Data.ProtoLens.FieldDescriptor+              "major"+              (Data.ProtoLens.ScalarField Data.ProtoLens.Int32Field ::+                 Data.ProtoLens.FieldTypeDescriptor Data.Int.Int32)+              (Data.ProtoLens.OptionalField+                 (Data.ProtoLens.Field.field @"maybe'major")) ::+              Data.ProtoLens.FieldDescriptor Version+        minor__field_descriptor+          = Data.ProtoLens.FieldDescriptor+              "minor"+              (Data.ProtoLens.ScalarField Data.ProtoLens.Int32Field ::+                 Data.ProtoLens.FieldTypeDescriptor Data.Int.Int32)+              (Data.ProtoLens.OptionalField+                 (Data.ProtoLens.Field.field @"maybe'minor")) ::+              Data.ProtoLens.FieldDescriptor Version+        patch__field_descriptor+          = Data.ProtoLens.FieldDescriptor+              "patch"+              (Data.ProtoLens.ScalarField Data.ProtoLens.Int32Field ::+                 Data.ProtoLens.FieldTypeDescriptor Data.Int.Int32)+              (Data.ProtoLens.OptionalField+                 (Data.ProtoLens.Field.field @"maybe'patch")) ::+              Data.ProtoLens.FieldDescriptor Version+        suffix__field_descriptor+          = Data.ProtoLens.FieldDescriptor+              "suffix"+              (Data.ProtoLens.ScalarField Data.ProtoLens.StringField ::+                 Data.ProtoLens.FieldTypeDescriptor Data.Text.Text)+              (Data.ProtoLens.OptionalField+                 (Data.ProtoLens.Field.field @"maybe'suffix")) ::+              Data.ProtoLens.FieldDescriptor Version+      in+        Data.Map.fromList+          [(Data.ProtoLens.Tag 1, major__field_descriptor),+           (Data.ProtoLens.Tag 2, minor__field_descriptor),+           (Data.ProtoLens.Tag 3, patch__field_descriptor),+           (Data.ProtoLens.Tag 4, suffix__field_descriptor)]+  unknownFields+    = Lens.Family2.Unchecked.lens+        _Version'_unknownFields+        (\ x__ y__ -> x__ {_Version'_unknownFields = y__})+  defMessage+    = Version'_constructor+        {_Version'major = Prelude.Nothing,+         _Version'minor = Prelude.Nothing, _Version'patch = Prelude.Nothing,+         _Version'suffix = Prelude.Nothing, _Version'_unknownFields = []}+  parseMessage+    = let+        loop :: Version -> Data.ProtoLens.Encoding.Bytes.Parser Version+        loop x+          = do end <- Data.ProtoLens.Encoding.Bytes.atEnd+               if end then+                   do (let missing = []+                       in+                         if Prelude.null missing then+                             Prelude.return ()+                         else+                             Prelude.fail+                               ((Prelude.++)+                                  "Missing required fields: "+                                  (Prelude.show (missing :: [Prelude.String]))))+                      Prelude.return+                        (Lens.Family2.over+                           Data.ProtoLens.unknownFields (\ !t -> Prelude.reverse t) x)+               else+                   do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt+                      case tag of+                        8 -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)+                                       (Prelude.fmap+                                          Prelude.fromIntegral+                                          Data.ProtoLens.Encoding.Bytes.getVarInt)+                                       "major"+                                loop (Lens.Family2.set (Data.ProtoLens.Field.field @"major") y x)+                        16+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)+                                       (Prelude.fmap+                                          Prelude.fromIntegral+                                          Data.ProtoLens.Encoding.Bytes.getVarInt)+                                       "minor"+                                loop (Lens.Family2.set (Data.ProtoLens.Field.field @"minor") y x)+                        24+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)+                                       (Prelude.fmap+                                          Prelude.fromIntegral+                                          Data.ProtoLens.Encoding.Bytes.getVarInt)+                                       "patch"+                                loop (Lens.Family2.set (Data.ProtoLens.Field.field @"patch") y x)+                        34+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)+                                       (do value <- do len <- Data.ProtoLens.Encoding.Bytes.getVarInt+                                                       Data.ProtoLens.Encoding.Bytes.getBytes+                                                         (Prelude.fromIntegral len)+                                           Data.ProtoLens.Encoding.Bytes.runEither+                                             (case Data.Text.Encoding.decodeUtf8' value of+                                                (Prelude.Left err)+                                                  -> Prelude.Left (Prelude.show err)+                                                (Prelude.Right r) -> Prelude.Right r))+                                       "suffix"+                                loop (Lens.Family2.set (Data.ProtoLens.Field.field @"suffix") y x)+                        wire+                          -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire+                                        wire+                                loop+                                  (Lens.Family2.over+                                     Data.ProtoLens.unknownFields (\ !t -> (:) y t) x)+      in+        (Data.ProtoLens.Encoding.Bytes.<?>)+          (do loop Data.ProtoLens.defMessage) "Version"+  buildMessage+    = \ _x+        -> (Data.Monoid.<>)+             (case+                  Lens.Family2.view (Data.ProtoLens.Field.field @"maybe'major") _x+              of+                Prelude.Nothing -> Data.Monoid.mempty+                (Prelude.Just _v)+                  -> (Data.Monoid.<>)+                       (Data.ProtoLens.Encoding.Bytes.putVarInt 8)+                       ((Prelude..)+                          Data.ProtoLens.Encoding.Bytes.putVarInt Prelude.fromIntegral _v))+             ((Data.Monoid.<>)+                (case+                     Lens.Family2.view (Data.ProtoLens.Field.field @"maybe'minor") _x+                 of+                   Prelude.Nothing -> Data.Monoid.mempty+                   (Prelude.Just _v)+                     -> (Data.Monoid.<>)+                          (Data.ProtoLens.Encoding.Bytes.putVarInt 16)+                          ((Prelude..)+                             Data.ProtoLens.Encoding.Bytes.putVarInt Prelude.fromIntegral _v))+                ((Data.Monoid.<>)+                   (case+                        Lens.Family2.view (Data.ProtoLens.Field.field @"maybe'patch") _x+                    of+                      Prelude.Nothing -> Data.Monoid.mempty+                      (Prelude.Just _v)+                        -> (Data.Monoid.<>)+                             (Data.ProtoLens.Encoding.Bytes.putVarInt 24)+                             ((Prelude..)+                                Data.ProtoLens.Encoding.Bytes.putVarInt Prelude.fromIntegral _v))+                   ((Data.Monoid.<>)+                      (case+                           Lens.Family2.view (Data.ProtoLens.Field.field @"maybe'suffix") _x+                       of+                         Prelude.Nothing -> Data.Monoid.mempty+                         (Prelude.Just _v)+                           -> (Data.Monoid.<>)+                                (Data.ProtoLens.Encoding.Bytes.putVarInt 34)+                                ((Prelude..)+                                   (\ bs+                                      -> (Data.Monoid.<>)+                                           (Data.ProtoLens.Encoding.Bytes.putVarInt+                                              (Prelude.fromIntegral (Data.ByteString.length bs)))+                                           (Data.ProtoLens.Encoding.Bytes.putBytes bs))+                                   Data.Text.Encoding.encodeUtf8+                                   _v))+                      (Data.ProtoLens.Encoding.Wire.buildFieldSet+                         (Lens.Family2.view Data.ProtoLens.unknownFields _x)))))+instance Control.DeepSeq.NFData Version where+  rnf+    = \ x__+        -> Control.DeepSeq.deepseq+             (_Version'_unknownFields x__)+             (Control.DeepSeq.deepseq+                (_Version'major x__)+                (Control.DeepSeq.deepseq+                   (_Version'minor x__)+                   (Control.DeepSeq.deepseq+                      (_Version'patch x__)+                      (Control.DeepSeq.deepseq (_Version'suffix x__) ()))))

@@ -0,0 +1,181 @@+{- This file was auto-generated from google/protobuf/compiler/plugin.proto by the proto-lens-protoc program. -}+{-# LANGUAGE ScopedTypeVariables, DataKinds, TypeFamilies, UndecidableInstances, GeneralizedNewtypeDeriving, MultiParamTypeClasses, FlexibleContexts, FlexibleInstances, PatternSynonyms, MagicHash, NoImplicitPrelude, DataKinds, BangPatterns, TypeApplications#-}+{-# OPTIONS_GHC -Wno-unused-imports#-}+{-# OPTIONS_GHC -Wno-duplicate-exports#-}+{-# OPTIONS_GHC -Wno-dodgy-exports#-}+module Proto.Google.Protobuf.Compiler.Plugin_Fields where+import qualified Data.ProtoLens.Runtime.Prelude as Prelude+import qualified Data.ProtoLens.Runtime.Data.Int as Data.Int+import qualified Data.ProtoLens.Runtime.Data.Monoid as Data.Monoid+import qualified Data.ProtoLens.Runtime.Data.Word as Data.Word+import qualified Data.ProtoLens.Runtime.Data.ProtoLens as Data.ProtoLens+import qualified Data.ProtoLens.Runtime.Data.ProtoLens.Encoding.Bytes as Data.ProtoLens.Encoding.Bytes+import qualified Data.ProtoLens.Runtime.Data.ProtoLens.Encoding.Growing as Data.ProtoLens.Encoding.Growing+import qualified Data.ProtoLens.Runtime.Data.ProtoLens.Encoding.Parser.Unsafe as Data.ProtoLens.Encoding.Parser.Unsafe+import qualified Data.ProtoLens.Runtime.Data.ProtoLens.Encoding.Wire as Data.ProtoLens.Encoding.Wire+import qualified Data.ProtoLens.Runtime.Data.ProtoLens.Field as Data.ProtoLens.Field+import qualified Data.ProtoLens.Runtime.Data.ProtoLens.Message.Enum as Data.ProtoLens.Message.Enum+import qualified Data.ProtoLens.Runtime.Data.ProtoLens.Service.Types as Data.ProtoLens.Service.Types+import qualified Data.ProtoLens.Runtime.Lens.Family2 as Lens.Family2+import qualified Data.ProtoLens.Runtime.Lens.Family2.Unchecked as Lens.Family2.Unchecked+import qualified Data.ProtoLens.Runtime.Data.Text as Data.Text+import qualified Data.ProtoLens.Runtime.Data.Map as Data.Map+import qualified Data.ProtoLens.Runtime.Data.ByteString as Data.ByteString+import qualified Data.ProtoLens.Runtime.Data.ByteString.Char8 as Data.ByteString.Char8+import qualified Data.ProtoLens.Runtime.Data.Text.Encoding as Data.Text.Encoding+import qualified Data.ProtoLens.Runtime.Data.Vector as Data.Vector+import qualified Data.ProtoLens.Runtime.Data.Vector.Generic as Data.Vector.Generic+import qualified Data.ProtoLens.Runtime.Data.Vector.Unboxed as Data.Vector.Unboxed+import qualified Data.ProtoLens.Runtime.Text.Read as Text.Read+import qualified Proto.Google.Protobuf.Descriptor+compilerVersion ::+  forall f s a.+  (Prelude.Functor f,+   Data.ProtoLens.Field.HasField s "compilerVersion" a) =>+  Lens.Family2.LensLike' f s a+compilerVersion = Data.ProtoLens.Field.field @"compilerVersion"+content ::+  forall f s a.+  (Prelude.Functor f, Data.ProtoLens.Field.HasField s "content" a) =>+  Lens.Family2.LensLike' f s a+content = Data.ProtoLens.Field.field @"content"+error ::+  forall f s a.+  (Prelude.Functor f, Data.ProtoLens.Field.HasField s "error" a) =>+  Lens.Family2.LensLike' f s a+error = Data.ProtoLens.Field.field @"error"+file ::+  forall f s a.+  (Prelude.Functor f, Data.ProtoLens.Field.HasField s "file" a) =>+  Lens.Family2.LensLike' f s a+file = Data.ProtoLens.Field.field @"file"+fileToGenerate ::+  forall f s a.+  (Prelude.Functor f,+   Data.ProtoLens.Field.HasField s "fileToGenerate" a) =>+  Lens.Family2.LensLike' f s a+fileToGenerate = Data.ProtoLens.Field.field @"fileToGenerate"+insertionPoint ::+  forall f s a.+  (Prelude.Functor f,+   Data.ProtoLens.Field.HasField s "insertionPoint" a) =>+  Lens.Family2.LensLike' f s a+insertionPoint = Data.ProtoLens.Field.field @"insertionPoint"+major ::+  forall f s a.+  (Prelude.Functor f, Data.ProtoLens.Field.HasField s "major" a) =>+  Lens.Family2.LensLike' f s a+major = Data.ProtoLens.Field.field @"major"+maybe'compilerVersion ::+  forall f s a.+  (Prelude.Functor f,+   Data.ProtoLens.Field.HasField s "maybe'compilerVersion" a) =>+  Lens.Family2.LensLike' f s a+maybe'compilerVersion+  = Data.ProtoLens.Field.field @"maybe'compilerVersion"+maybe'content ::+  forall f s a.+  (Prelude.Functor f,+   Data.ProtoLens.Field.HasField s "maybe'content" a) =>+  Lens.Family2.LensLike' f s a+maybe'content = Data.ProtoLens.Field.field @"maybe'content"+maybe'error ::+  forall f s a.+  (Prelude.Functor f,+   Data.ProtoLens.Field.HasField s "maybe'error" a) =>+  Lens.Family2.LensLike' f s a+maybe'error = Data.ProtoLens.Field.field @"maybe'error"+maybe'insertionPoint ::+  forall f s a.+  (Prelude.Functor f,+   Data.ProtoLens.Field.HasField s "maybe'insertionPoint" a) =>+  Lens.Family2.LensLike' f s a+maybe'insertionPoint+  = Data.ProtoLens.Field.field @"maybe'insertionPoint"+maybe'major ::+  forall f s a.+  (Prelude.Functor f,+   Data.ProtoLens.Field.HasField s "maybe'major" a) =>+  Lens.Family2.LensLike' f s a+maybe'major = Data.ProtoLens.Field.field @"maybe'major"+maybe'minor ::+  forall f s a.+  (Prelude.Functor f,+   Data.ProtoLens.Field.HasField s "maybe'minor" a) =>+  Lens.Family2.LensLike' f s a+maybe'minor = Data.ProtoLens.Field.field @"maybe'minor"+maybe'name ::+  forall f s a.+  (Prelude.Functor f,+   Data.ProtoLens.Field.HasField s "maybe'name" a) =>+  Lens.Family2.LensLike' f s a+maybe'name = Data.ProtoLens.Field.field @"maybe'name"+maybe'parameter ::+  forall f s a.+  (Prelude.Functor f,+   Data.ProtoLens.Field.HasField s "maybe'parameter" a) =>+  Lens.Family2.LensLike' f s a+maybe'parameter = Data.ProtoLens.Field.field @"maybe'parameter"+maybe'patch ::+  forall f s a.+  (Prelude.Functor f,+   Data.ProtoLens.Field.HasField s "maybe'patch" a) =>+  Lens.Family2.LensLike' f s a+maybe'patch = Data.ProtoLens.Field.field @"maybe'patch"+maybe'suffix ::+  forall f s a.+  (Prelude.Functor f,+   Data.ProtoLens.Field.HasField s "maybe'suffix" a) =>+  Lens.Family2.LensLike' f s a+maybe'suffix = Data.ProtoLens.Field.field @"maybe'suffix"+minor ::+  forall f s a.+  (Prelude.Functor f, Data.ProtoLens.Field.HasField s "minor" a) =>+  Lens.Family2.LensLike' f s a+minor = Data.ProtoLens.Field.field @"minor"+name ::+  forall f s a.+  (Prelude.Functor f, Data.ProtoLens.Field.HasField s "name" a) =>+  Lens.Family2.LensLike' f s a+name = Data.ProtoLens.Field.field @"name"+parameter ::+  forall f s a.+  (Prelude.Functor f,+   Data.ProtoLens.Field.HasField s "parameter" a) =>+  Lens.Family2.LensLike' f s a+parameter = Data.ProtoLens.Field.field @"parameter"+patch ::+  forall f s a.+  (Prelude.Functor f, Data.ProtoLens.Field.HasField s "patch" a) =>+  Lens.Family2.LensLike' f s a+patch = Data.ProtoLens.Field.field @"patch"+protoFile ::+  forall f s a.+  (Prelude.Functor f,+   Data.ProtoLens.Field.HasField s "protoFile" a) =>+  Lens.Family2.LensLike' f s a+protoFile = Data.ProtoLens.Field.field @"protoFile"+suffix ::+  forall f s a.+  (Prelude.Functor f, Data.ProtoLens.Field.HasField s "suffix" a) =>+  Lens.Family2.LensLike' f s a+suffix = Data.ProtoLens.Field.field @"suffix"+vec'file ::+  forall f s a.+  (Prelude.Functor f,+   Data.ProtoLens.Field.HasField s "vec'file" a) =>+  Lens.Family2.LensLike' f s a+vec'file = Data.ProtoLens.Field.field @"vec'file"+vec'fileToGenerate ::+  forall f s a.+  (Prelude.Functor f,+   Data.ProtoLens.Field.HasField s "vec'fileToGenerate" a) =>+  Lens.Family2.LensLike' f s a+vec'fileToGenerate+  = Data.ProtoLens.Field.field @"vec'fileToGenerate"+vec'protoFile ::+  forall f s a.+  (Prelude.Functor f,+   Data.ProtoLens.Field.HasField s "vec'protoFile" a) =>+  Lens.Family2.LensLike' f s a+vec'protoFile = Data.ProtoLens.Field.field @"vec'protoFile"

@@ -0,0 +1,9947 @@+{- This file was auto-generated from google/protobuf/descriptor.proto by the proto-lens-protoc program. -}+{-# LANGUAGE ScopedTypeVariables, DataKinds, TypeFamilies, UndecidableInstances, GeneralizedNewtypeDeriving, MultiParamTypeClasses, FlexibleContexts, FlexibleInstances, PatternSynonyms, MagicHash, NoImplicitPrelude, DataKinds, BangPatterns, TypeApplications#-}+{-# OPTIONS_GHC -Wno-unused-imports#-}+{-# OPTIONS_GHC -Wno-duplicate-exports#-}+{-# OPTIONS_GHC -Wno-dodgy-exports#-}+module Proto.Google.Protobuf.Descriptor (+        DescriptorProto(), DescriptorProto'ExtensionRange(),+        DescriptorProto'ReservedRange(), EnumDescriptorProto(),+        EnumDescriptorProto'EnumReservedRange(), EnumOptions(),+        EnumValueDescriptorProto(), EnumValueOptions(),+        ExtensionRangeOptions(), FieldDescriptorProto(),+        FieldDescriptorProto'Label(..), FieldDescriptorProto'Label(),+        FieldDescriptorProto'Type(..), FieldDescriptorProto'Type(),+        FieldOptions(), FieldOptions'CType(..), FieldOptions'CType(),+        FieldOptions'JSType(..), FieldOptions'JSType(),+        FileDescriptorProto(), FileDescriptorSet(), FileOptions(),+        FileOptions'OptimizeMode(..), FileOptions'OptimizeMode(),+        GeneratedCodeInfo(), GeneratedCodeInfo'Annotation(),+        MessageOptions(), MethodDescriptorProto(), MethodOptions(),+        MethodOptions'IdempotencyLevel(..),+        MethodOptions'IdempotencyLevel(), OneofDescriptorProto(),+        OneofOptions(), ServiceDescriptorProto(), ServiceOptions(),+        SourceCodeInfo(), SourceCodeInfo'Location(), UninterpretedOption(),+        UninterpretedOption'NamePart()+    ) where+import qualified Data.ProtoLens.Runtime.Control.DeepSeq as Control.DeepSeq+import qualified Data.ProtoLens.Runtime.Data.ProtoLens.Prism as Data.ProtoLens.Prism+import qualified Data.ProtoLens.Runtime.Prelude as Prelude+import qualified Data.ProtoLens.Runtime.Data.Int as Data.Int+import qualified Data.ProtoLens.Runtime.Data.Monoid as Data.Monoid+import qualified Data.ProtoLens.Runtime.Data.Word as Data.Word+import qualified Data.ProtoLens.Runtime.Data.ProtoLens as Data.ProtoLens+import qualified Data.ProtoLens.Runtime.Data.ProtoLens.Encoding.Bytes as Data.ProtoLens.Encoding.Bytes+import qualified Data.ProtoLens.Runtime.Data.ProtoLens.Encoding.Growing as Data.ProtoLens.Encoding.Growing+import qualified Data.ProtoLens.Runtime.Data.ProtoLens.Encoding.Parser.Unsafe as Data.ProtoLens.Encoding.Parser.Unsafe+import qualified Data.ProtoLens.Runtime.Data.ProtoLens.Encoding.Wire as Data.ProtoLens.Encoding.Wire+import qualified Data.ProtoLens.Runtime.Data.ProtoLens.Field as Data.ProtoLens.Field+import qualified Data.ProtoLens.Runtime.Data.ProtoLens.Message.Enum as Data.ProtoLens.Message.Enum+import qualified Data.ProtoLens.Runtime.Data.ProtoLens.Service.Types as Data.ProtoLens.Service.Types+import qualified Data.ProtoLens.Runtime.Lens.Family2 as Lens.Family2+import qualified Data.ProtoLens.Runtime.Lens.Family2.Unchecked as Lens.Family2.Unchecked+import qualified Data.ProtoLens.Runtime.Data.Text as Data.Text+import qualified Data.ProtoLens.Runtime.Data.Map as Data.Map+import qualified Data.ProtoLens.Runtime.Data.ByteString as Data.ByteString+import qualified Data.ProtoLens.Runtime.Data.ByteString.Char8 as Data.ByteString.Char8+import qualified Data.ProtoLens.Runtime.Data.Text.Encoding as Data.Text.Encoding+import qualified Data.ProtoLens.Runtime.Data.Vector as Data.Vector+import qualified Data.ProtoLens.Runtime.Data.Vector.Generic as Data.Vector.Generic+import qualified Data.ProtoLens.Runtime.Data.Vector.Unboxed as Data.Vector.Unboxed+import qualified Data.ProtoLens.Runtime.Text.Read as Text.Read+{- | Fields :+     +         * 'Proto.Google.Protobuf.Descriptor_Fields.name' @:: Lens' DescriptorProto Data.Text.Text@+         * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'name' @:: Lens' DescriptorProto (Prelude.Maybe Data.Text.Text)@+         * 'Proto.Google.Protobuf.Descriptor_Fields.field' @:: Lens' DescriptorProto [FieldDescriptorProto]@+         * 'Proto.Google.Protobuf.Descriptor_Fields.vec'field' @:: Lens' DescriptorProto (Data.Vector.Vector FieldDescriptorProto)@+         * 'Proto.Google.Protobuf.Descriptor_Fields.extension' @:: Lens' DescriptorProto [FieldDescriptorProto]@+         * 'Proto.Google.Protobuf.Descriptor_Fields.vec'extension' @:: Lens' DescriptorProto (Data.Vector.Vector FieldDescriptorProto)@+         * 'Proto.Google.Protobuf.Descriptor_Fields.nestedType' @:: Lens' DescriptorProto [DescriptorProto]@+         * 'Proto.Google.Protobuf.Descriptor_Fields.vec'nestedType' @:: Lens' DescriptorProto (Data.Vector.Vector DescriptorProto)@+         * 'Proto.Google.Protobuf.Descriptor_Fields.enumType' @:: Lens' DescriptorProto [EnumDescriptorProto]@+         * 'Proto.Google.Protobuf.Descriptor_Fields.vec'enumType' @:: Lens' DescriptorProto (Data.Vector.Vector EnumDescriptorProto)@+         * 'Proto.Google.Protobuf.Descriptor_Fields.extensionRange' @:: Lens' DescriptorProto [DescriptorProto'ExtensionRange]@+         * 'Proto.Google.Protobuf.Descriptor_Fields.vec'extensionRange' @:: Lens' DescriptorProto (Data.Vector.Vector DescriptorProto'ExtensionRange)@+         * 'Proto.Google.Protobuf.Descriptor_Fields.oneofDecl' @:: Lens' DescriptorProto [OneofDescriptorProto]@+         * 'Proto.Google.Protobuf.Descriptor_Fields.vec'oneofDecl' @:: Lens' DescriptorProto (Data.Vector.Vector OneofDescriptorProto)@+         * 'Proto.Google.Protobuf.Descriptor_Fields.options' @:: Lens' DescriptorProto MessageOptions@+         * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'options' @:: Lens' DescriptorProto (Prelude.Maybe MessageOptions)@+         * 'Proto.Google.Protobuf.Descriptor_Fields.reservedRange' @:: Lens' DescriptorProto [DescriptorProto'ReservedRange]@+         * 'Proto.Google.Protobuf.Descriptor_Fields.vec'reservedRange' @:: Lens' DescriptorProto (Data.Vector.Vector DescriptorProto'ReservedRange)@+         * 'Proto.Google.Protobuf.Descriptor_Fields.reservedName' @:: Lens' DescriptorProto [Data.Text.Text]@+         * 'Proto.Google.Protobuf.Descriptor_Fields.vec'reservedName' @:: Lens' DescriptorProto (Data.Vector.Vector Data.Text.Text)@ -}+data DescriptorProto+  = DescriptorProto'_constructor {_DescriptorProto'name :: !(Prelude.Maybe Data.Text.Text),+                                  _DescriptorProto'field :: !(Data.Vector.Vector FieldDescriptorProto),+                                  _DescriptorProto'extension :: !(Data.Vector.Vector FieldDescriptorProto),+                                  _DescriptorProto'nestedType :: !(Data.Vector.Vector DescriptorProto),+                                  _DescriptorProto'enumType :: !(Data.Vector.Vector EnumDescriptorProto),+                                  _DescriptorProto'extensionRange :: !(Data.Vector.Vector DescriptorProto'ExtensionRange),+                                  _DescriptorProto'oneofDecl :: !(Data.Vector.Vector OneofDescriptorProto),+                                  _DescriptorProto'options :: !(Prelude.Maybe MessageOptions),+                                  _DescriptorProto'reservedRange :: !(Data.Vector.Vector DescriptorProto'ReservedRange),+                                  _DescriptorProto'reservedName :: !(Data.Vector.Vector Data.Text.Text),+                                  _DescriptorProto'_unknownFields :: !Data.ProtoLens.FieldSet}+  deriving (Prelude.Eq, Prelude.Ord)+instance Prelude.Show DescriptorProto where+  showsPrec _ __x __s+    = Prelude.showChar+        '{'+        (Prelude.showString+           (Data.ProtoLens.showMessageShort __x) (Prelude.showChar '}' __s))+instance Data.ProtoLens.Field.HasField DescriptorProto "name" Data.Text.Text where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _DescriptorProto'name+           (\ x__ y__ -> x__ {_DescriptorProto'name = y__}))+        (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault)+instance Data.ProtoLens.Field.HasField DescriptorProto "maybe'name" (Prelude.Maybe Data.Text.Text) where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _DescriptorProto'name+           (\ x__ y__ -> x__ {_DescriptorProto'name = y__}))+        Prelude.id+instance Data.ProtoLens.Field.HasField DescriptorProto "field" [FieldDescriptorProto] where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _DescriptorProto'field+           (\ x__ y__ -> x__ {_DescriptorProto'field = y__}))+        (Lens.Family2.Unchecked.lens+           Data.Vector.Generic.toList+           (\ _ y__ -> Data.Vector.Generic.fromList y__))+instance Data.ProtoLens.Field.HasField DescriptorProto "vec'field" (Data.Vector.Vector FieldDescriptorProto) where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _DescriptorProto'field+           (\ x__ y__ -> x__ {_DescriptorProto'field = y__}))+        Prelude.id+instance Data.ProtoLens.Field.HasField DescriptorProto "extension" [FieldDescriptorProto] where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _DescriptorProto'extension+           (\ x__ y__ -> x__ {_DescriptorProto'extension = y__}))+        (Lens.Family2.Unchecked.lens+           Data.Vector.Generic.toList+           (\ _ y__ -> Data.Vector.Generic.fromList y__))+instance Data.ProtoLens.Field.HasField DescriptorProto "vec'extension" (Data.Vector.Vector FieldDescriptorProto) where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _DescriptorProto'extension+           (\ x__ y__ -> x__ {_DescriptorProto'extension = y__}))+        Prelude.id+instance Data.ProtoLens.Field.HasField DescriptorProto "nestedType" [DescriptorProto] where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _DescriptorProto'nestedType+           (\ x__ y__ -> x__ {_DescriptorProto'nestedType = y__}))+        (Lens.Family2.Unchecked.lens+           Data.Vector.Generic.toList+           (\ _ y__ -> Data.Vector.Generic.fromList y__))+instance Data.ProtoLens.Field.HasField DescriptorProto "vec'nestedType" (Data.Vector.Vector DescriptorProto) where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _DescriptorProto'nestedType+           (\ x__ y__ -> x__ {_DescriptorProto'nestedType = y__}))+        Prelude.id+instance Data.ProtoLens.Field.HasField DescriptorProto "enumType" [EnumDescriptorProto] where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _DescriptorProto'enumType+           (\ x__ y__ -> x__ {_DescriptorProto'enumType = y__}))+        (Lens.Family2.Unchecked.lens+           Data.Vector.Generic.toList+           (\ _ y__ -> Data.Vector.Generic.fromList y__))+instance Data.ProtoLens.Field.HasField DescriptorProto "vec'enumType" (Data.Vector.Vector EnumDescriptorProto) where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _DescriptorProto'enumType+           (\ x__ y__ -> x__ {_DescriptorProto'enumType = y__}))+        Prelude.id+instance Data.ProtoLens.Field.HasField DescriptorProto "extensionRange" [DescriptorProto'ExtensionRange] where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _DescriptorProto'extensionRange+           (\ x__ y__ -> x__ {_DescriptorProto'extensionRange = y__}))+        (Lens.Family2.Unchecked.lens+           Data.Vector.Generic.toList+           (\ _ y__ -> Data.Vector.Generic.fromList y__))+instance Data.ProtoLens.Field.HasField DescriptorProto "vec'extensionRange" (Data.Vector.Vector DescriptorProto'ExtensionRange) where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _DescriptorProto'extensionRange+           (\ x__ y__ -> x__ {_DescriptorProto'extensionRange = y__}))+        Prelude.id+instance Data.ProtoLens.Field.HasField DescriptorProto "oneofDecl" [OneofDescriptorProto] where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _DescriptorProto'oneofDecl+           (\ x__ y__ -> x__ {_DescriptorProto'oneofDecl = y__}))+        (Lens.Family2.Unchecked.lens+           Data.Vector.Generic.toList+           (\ _ y__ -> Data.Vector.Generic.fromList y__))+instance Data.ProtoLens.Field.HasField DescriptorProto "vec'oneofDecl" (Data.Vector.Vector OneofDescriptorProto) where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _DescriptorProto'oneofDecl+           (\ x__ y__ -> x__ {_DescriptorProto'oneofDecl = y__}))+        Prelude.id+instance Data.ProtoLens.Field.HasField DescriptorProto "options" MessageOptions where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _DescriptorProto'options+           (\ x__ y__ -> x__ {_DescriptorProto'options = y__}))+        (Data.ProtoLens.maybeLens Data.ProtoLens.defMessage)+instance Data.ProtoLens.Field.HasField DescriptorProto "maybe'options" (Prelude.Maybe MessageOptions) where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _DescriptorProto'options+           (\ x__ y__ -> x__ {_DescriptorProto'options = y__}))+        Prelude.id+instance Data.ProtoLens.Field.HasField DescriptorProto "reservedRange" [DescriptorProto'ReservedRange] where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _DescriptorProto'reservedRange+           (\ x__ y__ -> x__ {_DescriptorProto'reservedRange = y__}))+        (Lens.Family2.Unchecked.lens+           Data.Vector.Generic.toList+           (\ _ y__ -> Data.Vector.Generic.fromList y__))+instance Data.ProtoLens.Field.HasField DescriptorProto "vec'reservedRange" (Data.Vector.Vector DescriptorProto'ReservedRange) where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _DescriptorProto'reservedRange+           (\ x__ y__ -> x__ {_DescriptorProto'reservedRange = y__}))+        Prelude.id+instance Data.ProtoLens.Field.HasField DescriptorProto "reservedName" [Data.Text.Text] where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _DescriptorProto'reservedName+           (\ x__ y__ -> x__ {_DescriptorProto'reservedName = y__}))+        (Lens.Family2.Unchecked.lens+           Data.Vector.Generic.toList+           (\ _ y__ -> Data.Vector.Generic.fromList y__))+instance Data.ProtoLens.Field.HasField DescriptorProto "vec'reservedName" (Data.Vector.Vector Data.Text.Text) where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _DescriptorProto'reservedName+           (\ x__ y__ -> x__ {_DescriptorProto'reservedName = y__}))+        Prelude.id+instance Data.ProtoLens.Message DescriptorProto where+  messageName _ = Data.Text.pack "google.protobuf.DescriptorProto"+  fieldsByTag+    = let+        name__field_descriptor+          = Data.ProtoLens.FieldDescriptor+              "name"+              (Data.ProtoLens.ScalarField Data.ProtoLens.StringField ::+                 Data.ProtoLens.FieldTypeDescriptor Data.Text.Text)+              (Data.ProtoLens.OptionalField+                 (Data.ProtoLens.Field.field @"maybe'name")) ::+              Data.ProtoLens.FieldDescriptor DescriptorProto+        field__field_descriptor+          = Data.ProtoLens.FieldDescriptor+              "field"+              (Data.ProtoLens.MessageField Data.ProtoLens.MessageType ::+                 Data.ProtoLens.FieldTypeDescriptor FieldDescriptorProto)+              (Data.ProtoLens.RepeatedField+                 Data.ProtoLens.Unpacked (Data.ProtoLens.Field.field @"field")) ::+              Data.ProtoLens.FieldDescriptor DescriptorProto+        extension__field_descriptor+          = Data.ProtoLens.FieldDescriptor+              "extension"+              (Data.ProtoLens.MessageField Data.ProtoLens.MessageType ::+                 Data.ProtoLens.FieldTypeDescriptor FieldDescriptorProto)+              (Data.ProtoLens.RepeatedField+                 Data.ProtoLens.Unpacked+                 (Data.ProtoLens.Field.field @"extension")) ::+              Data.ProtoLens.FieldDescriptor DescriptorProto+        nestedType__field_descriptor+          = Data.ProtoLens.FieldDescriptor+              "nested_type"+              (Data.ProtoLens.MessageField Data.ProtoLens.MessageType ::+                 Data.ProtoLens.FieldTypeDescriptor DescriptorProto)+              (Data.ProtoLens.RepeatedField+                 Data.ProtoLens.Unpacked+                 (Data.ProtoLens.Field.field @"nestedType")) ::+              Data.ProtoLens.FieldDescriptor DescriptorProto+        enumType__field_descriptor+          = Data.ProtoLens.FieldDescriptor+              "enum_type"+              (Data.ProtoLens.MessageField Data.ProtoLens.MessageType ::+                 Data.ProtoLens.FieldTypeDescriptor EnumDescriptorProto)+              (Data.ProtoLens.RepeatedField+                 Data.ProtoLens.Unpacked+                 (Data.ProtoLens.Field.field @"enumType")) ::+              Data.ProtoLens.FieldDescriptor DescriptorProto+        extensionRange__field_descriptor+          = Data.ProtoLens.FieldDescriptor+              "extension_range"+              (Data.ProtoLens.MessageField Data.ProtoLens.MessageType ::+                 Data.ProtoLens.FieldTypeDescriptor DescriptorProto'ExtensionRange)+              (Data.ProtoLens.RepeatedField+                 Data.ProtoLens.Unpacked+                 (Data.ProtoLens.Field.field @"extensionRange")) ::+              Data.ProtoLens.FieldDescriptor DescriptorProto+        oneofDecl__field_descriptor+          = Data.ProtoLens.FieldDescriptor+              "oneof_decl"+              (Data.ProtoLens.MessageField Data.ProtoLens.MessageType ::+                 Data.ProtoLens.FieldTypeDescriptor OneofDescriptorProto)+              (Data.ProtoLens.RepeatedField+                 Data.ProtoLens.Unpacked+                 (Data.ProtoLens.Field.field @"oneofDecl")) ::+              Data.ProtoLens.FieldDescriptor DescriptorProto+        options__field_descriptor+          = Data.ProtoLens.FieldDescriptor+              "options"+              (Data.ProtoLens.MessageField Data.ProtoLens.MessageType ::+                 Data.ProtoLens.FieldTypeDescriptor MessageOptions)+              (Data.ProtoLens.OptionalField+                 (Data.ProtoLens.Field.field @"maybe'options")) ::+              Data.ProtoLens.FieldDescriptor DescriptorProto+        reservedRange__field_descriptor+          = Data.ProtoLens.FieldDescriptor+              "reserved_range"+              (Data.ProtoLens.MessageField Data.ProtoLens.MessageType ::+                 Data.ProtoLens.FieldTypeDescriptor DescriptorProto'ReservedRange)+              (Data.ProtoLens.RepeatedField+                 Data.ProtoLens.Unpacked+                 (Data.ProtoLens.Field.field @"reservedRange")) ::+              Data.ProtoLens.FieldDescriptor DescriptorProto+        reservedName__field_descriptor+          = Data.ProtoLens.FieldDescriptor+              "reserved_name"+              (Data.ProtoLens.ScalarField Data.ProtoLens.StringField ::+                 Data.ProtoLens.FieldTypeDescriptor Data.Text.Text)+              (Data.ProtoLens.RepeatedField+                 Data.ProtoLens.Unpacked+                 (Data.ProtoLens.Field.field @"reservedName")) ::+              Data.ProtoLens.FieldDescriptor DescriptorProto+      in+        Data.Map.fromList+          [(Data.ProtoLens.Tag 1, name__field_descriptor),+           (Data.ProtoLens.Tag 2, field__field_descriptor),+           (Data.ProtoLens.Tag 6, extension__field_descriptor),+           (Data.ProtoLens.Tag 3, nestedType__field_descriptor),+           (Data.ProtoLens.Tag 4, enumType__field_descriptor),+           (Data.ProtoLens.Tag 5, extensionRange__field_descriptor),+           (Data.ProtoLens.Tag 8, oneofDecl__field_descriptor),+           (Data.ProtoLens.Tag 7, options__field_descriptor),+           (Data.ProtoLens.Tag 9, reservedRange__field_descriptor),+           (Data.ProtoLens.Tag 10, reservedName__field_descriptor)]+  unknownFields+    = Lens.Family2.Unchecked.lens+        _DescriptorProto'_unknownFields+        (\ x__ y__ -> x__ {_DescriptorProto'_unknownFields = y__})+  defMessage+    = DescriptorProto'_constructor+        {_DescriptorProto'name = Prelude.Nothing,+         _DescriptorProto'field = Data.Vector.Generic.empty,+         _DescriptorProto'extension = Data.Vector.Generic.empty,+         _DescriptorProto'nestedType = Data.Vector.Generic.empty,+         _DescriptorProto'enumType = Data.Vector.Generic.empty,+         _DescriptorProto'extensionRange = Data.Vector.Generic.empty,+         _DescriptorProto'oneofDecl = Data.Vector.Generic.empty,+         _DescriptorProto'options = Prelude.Nothing,+         _DescriptorProto'reservedRange = Data.Vector.Generic.empty,+         _DescriptorProto'reservedName = Data.Vector.Generic.empty,+         _DescriptorProto'_unknownFields = []}+  parseMessage+    = let+        loop ::+          DescriptorProto+          -> Data.ProtoLens.Encoding.Growing.Growing Data.Vector.Vector Data.ProtoLens.Encoding.Growing.RealWorld EnumDescriptorProto+             -> Data.ProtoLens.Encoding.Growing.Growing Data.Vector.Vector Data.ProtoLens.Encoding.Growing.RealWorld FieldDescriptorProto+                -> Data.ProtoLens.Encoding.Growing.Growing Data.Vector.Vector Data.ProtoLens.Encoding.Growing.RealWorld DescriptorProto'ExtensionRange+                   -> Data.ProtoLens.Encoding.Growing.Growing Data.Vector.Vector Data.ProtoLens.Encoding.Growing.RealWorld FieldDescriptorProto+                      -> Data.ProtoLens.Encoding.Growing.Growing Data.Vector.Vector Data.ProtoLens.Encoding.Growing.RealWorld DescriptorProto+                         -> Data.ProtoLens.Encoding.Growing.Growing Data.Vector.Vector Data.ProtoLens.Encoding.Growing.RealWorld OneofDescriptorProto+                            -> Data.ProtoLens.Encoding.Growing.Growing Data.Vector.Vector Data.ProtoLens.Encoding.Growing.RealWorld Data.Text.Text+                               -> Data.ProtoLens.Encoding.Growing.Growing Data.Vector.Vector Data.ProtoLens.Encoding.Growing.RealWorld DescriptorProto'ReservedRange+                                  -> Data.ProtoLens.Encoding.Bytes.Parser DescriptorProto+        loop+          x+          mutable'enumType+          mutable'extension+          mutable'extensionRange+          mutable'field+          mutable'nestedType+          mutable'oneofDecl+          mutable'reservedName+          mutable'reservedRange+          = do end <- Data.ProtoLens.Encoding.Bytes.atEnd+               if end then+                   do frozen'enumType <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO+                                           (Data.ProtoLens.Encoding.Growing.unsafeFreeze+                                              mutable'enumType)+                      frozen'extension <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO+                                            (Data.ProtoLens.Encoding.Growing.unsafeFreeze+                                               mutable'extension)+                      frozen'extensionRange <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO+                                                 (Data.ProtoLens.Encoding.Growing.unsafeFreeze+                                                    mutable'extensionRange)+                      frozen'field <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO+                                        (Data.ProtoLens.Encoding.Growing.unsafeFreeze mutable'field)+                      frozen'nestedType <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO+                                             (Data.ProtoLens.Encoding.Growing.unsafeFreeze+                                                mutable'nestedType)+                      frozen'oneofDecl <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO+                                            (Data.ProtoLens.Encoding.Growing.unsafeFreeze+                                               mutable'oneofDecl)+                      frozen'reservedName <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO+                                               (Data.ProtoLens.Encoding.Growing.unsafeFreeze+                                                  mutable'reservedName)+                      frozen'reservedRange <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO+                                                (Data.ProtoLens.Encoding.Growing.unsafeFreeze+                                                   mutable'reservedRange)+                      (let missing = []+                       in+                         if Prelude.null missing then+                             Prelude.return ()+                         else+                             Prelude.fail+                               ((Prelude.++)+                                  "Missing required fields: "+                                  (Prelude.show (missing :: [Prelude.String]))))+                      Prelude.return+                        (Lens.Family2.over+                           Data.ProtoLens.unknownFields+                           (\ !t -> Prelude.reverse t)+                           (Lens.Family2.set+                              (Data.ProtoLens.Field.field @"vec'enumType")+                              frozen'enumType+                              (Lens.Family2.set+                                 (Data.ProtoLens.Field.field @"vec'extension")+                                 frozen'extension+                                 (Lens.Family2.set+                                    (Data.ProtoLens.Field.field @"vec'extensionRange")+                                    frozen'extensionRange+                                    (Lens.Family2.set+                                       (Data.ProtoLens.Field.field @"vec'field")+                                       frozen'field+                                       (Lens.Family2.set+                                          (Data.ProtoLens.Field.field @"vec'nestedType")+                                          frozen'nestedType+                                          (Lens.Family2.set+                                             (Data.ProtoLens.Field.field @"vec'oneofDecl")+                                             frozen'oneofDecl+                                             (Lens.Family2.set+                                                (Data.ProtoLens.Field.field @"vec'reservedName")+                                                frozen'reservedName+                                                (Lens.Family2.set+                                                   (Data.ProtoLens.Field.field @"vec'reservedRange")+                                                   frozen'reservedRange+                                                   x)))))))))+               else+                   do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt+                      case tag of+                        10+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)+                                       (do value <- do len <- Data.ProtoLens.Encoding.Bytes.getVarInt+                                                       Data.ProtoLens.Encoding.Bytes.getBytes+                                                         (Prelude.fromIntegral len)+                                           Data.ProtoLens.Encoding.Bytes.runEither+                                             (case Data.Text.Encoding.decodeUtf8' value of+                                                (Prelude.Left err)+                                                  -> Prelude.Left (Prelude.show err)+                                                (Prelude.Right r) -> Prelude.Right r))+                                       "name"+                                loop+                                  (Lens.Family2.set (Data.ProtoLens.Field.field @"name") y x)+                                  mutable'enumType+                                  mutable'extension+                                  mutable'extensionRange+                                  mutable'field+                                  mutable'nestedType+                                  mutable'oneofDecl+                                  mutable'reservedName+                                  mutable'reservedRange+                        18+                          -> do !y <- (Data.ProtoLens.Encoding.Bytes.<?>)+                                        (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt+                                            Data.ProtoLens.Encoding.Bytes.isolate+                                              (Prelude.fromIntegral len)+                                              Data.ProtoLens.parseMessage)+                                        "field"+                                v <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO+                                       (Data.ProtoLens.Encoding.Growing.append mutable'field y)+                                loop+                                  x+                                  mutable'enumType+                                  mutable'extension+                                  mutable'extensionRange+                                  v+                                  mutable'nestedType+                                  mutable'oneofDecl+                                  mutable'reservedName+                                  mutable'reservedRange+                        50+                          -> do !y <- (Data.ProtoLens.Encoding.Bytes.<?>)+                                        (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt+                                            Data.ProtoLens.Encoding.Bytes.isolate+                                              (Prelude.fromIntegral len)+                                              Data.ProtoLens.parseMessage)+                                        "extension"+                                v <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO+                                       (Data.ProtoLens.Encoding.Growing.append mutable'extension y)+                                loop+                                  x+                                  mutable'enumType+                                  v+                                  mutable'extensionRange+                                  mutable'field+                                  mutable'nestedType+                                  mutable'oneofDecl+                                  mutable'reservedName+                                  mutable'reservedRange+                        26+                          -> do !y <- (Data.ProtoLens.Encoding.Bytes.<?>)+                                        (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt+                                            Data.ProtoLens.Encoding.Bytes.isolate+                                              (Prelude.fromIntegral len)+                                              Data.ProtoLens.parseMessage)+                                        "nested_type"+                                v <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO+                                       (Data.ProtoLens.Encoding.Growing.append mutable'nestedType y)+                                loop+                                  x+                                  mutable'enumType+                                  mutable'extension+                                  mutable'extensionRange+                                  mutable'field+                                  v+                                  mutable'oneofDecl+                                  mutable'reservedName+                                  mutable'reservedRange+                        34+                          -> do !y <- (Data.ProtoLens.Encoding.Bytes.<?>)+                                        (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt+                                            Data.ProtoLens.Encoding.Bytes.isolate+                                              (Prelude.fromIntegral len)+                                              Data.ProtoLens.parseMessage)+                                        "enum_type"+                                v <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO+                                       (Data.ProtoLens.Encoding.Growing.append mutable'enumType y)+                                loop+                                  x+                                  v+                                  mutable'extension+                                  mutable'extensionRange+                                  mutable'field+                                  mutable'nestedType+                                  mutable'oneofDecl+                                  mutable'reservedName+                                  mutable'reservedRange+                        42+                          -> do !y <- (Data.ProtoLens.Encoding.Bytes.<?>)+                                        (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt+                                            Data.ProtoLens.Encoding.Bytes.isolate+                                              (Prelude.fromIntegral len)+                                              Data.ProtoLens.parseMessage)+                                        "extension_range"+                                v <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO+                                       (Data.ProtoLens.Encoding.Growing.append+                                          mutable'extensionRange y)+                                loop+                                  x+                                  mutable'enumType+                                  mutable'extension+                                  v+                                  mutable'field+                                  mutable'nestedType+                                  mutable'oneofDecl+                                  mutable'reservedName+                                  mutable'reservedRange+                        66+                          -> do !y <- (Data.ProtoLens.Encoding.Bytes.<?>)+                                        (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt+                                            Data.ProtoLens.Encoding.Bytes.isolate+                                              (Prelude.fromIntegral len)+                                              Data.ProtoLens.parseMessage)+                                        "oneof_decl"+                                v <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO+                                       (Data.ProtoLens.Encoding.Growing.append mutable'oneofDecl y)+                                loop+                                  x+                                  mutable'enumType+                                  mutable'extension+                                  mutable'extensionRange+                                  mutable'field+                                  mutable'nestedType+                                  v+                                  mutable'reservedName+                                  mutable'reservedRange+                        58+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)+                                       (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt+                                           Data.ProtoLens.Encoding.Bytes.isolate+                                             (Prelude.fromIntegral len) Data.ProtoLens.parseMessage)+                                       "options"+                                loop+                                  (Lens.Family2.set (Data.ProtoLens.Field.field @"options") y x)+                                  mutable'enumType+                                  mutable'extension+                                  mutable'extensionRange+                                  mutable'field+                                  mutable'nestedType+                                  mutable'oneofDecl+                                  mutable'reservedName+                                  mutable'reservedRange+                        74+                          -> do !y <- (Data.ProtoLens.Encoding.Bytes.<?>)+                                        (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt+                                            Data.ProtoLens.Encoding.Bytes.isolate+                                              (Prelude.fromIntegral len)+                                              Data.ProtoLens.parseMessage)+                                        "reserved_range"+                                v <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO+                                       (Data.ProtoLens.Encoding.Growing.append+                                          mutable'reservedRange y)+                                loop+                                  x+                                  mutable'enumType+                                  mutable'extension+                                  mutable'extensionRange+                                  mutable'field+                                  mutable'nestedType+                                  mutable'oneofDecl+                                  mutable'reservedName+                                  v+                        82+                          -> do !y <- (Data.ProtoLens.Encoding.Bytes.<?>)+                                        (do value <- do len <- Data.ProtoLens.Encoding.Bytes.getVarInt+                                                        Data.ProtoLens.Encoding.Bytes.getBytes+                                                          (Prelude.fromIntegral len)+                                            Data.ProtoLens.Encoding.Bytes.runEither+                                              (case Data.Text.Encoding.decodeUtf8' value of+                                                 (Prelude.Left err)+                                                   -> Prelude.Left (Prelude.show err)+                                                 (Prelude.Right r) -> Prelude.Right r))+                                        "reserved_name"+                                v <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO+                                       (Data.ProtoLens.Encoding.Growing.append+                                          mutable'reservedName y)+                                loop+                                  x+                                  mutable'enumType+                                  mutable'extension+                                  mutable'extensionRange+                                  mutable'field+                                  mutable'nestedType+                                  mutable'oneofDecl+                                  v+                                  mutable'reservedRange+                        wire+                          -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire+                                        wire+                                loop+                                  (Lens.Family2.over+                                     Data.ProtoLens.unknownFields (\ !t -> (:) y t) x)+                                  mutable'enumType+                                  mutable'extension+                                  mutable'extensionRange+                                  mutable'field+                                  mutable'nestedType+                                  mutable'oneofDecl+                                  mutable'reservedName+                                  mutable'reservedRange+      in+        (Data.ProtoLens.Encoding.Bytes.<?>)+          (do mutable'enumType <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO+                                    Data.ProtoLens.Encoding.Growing.new+              mutable'extension <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO+                                     Data.ProtoLens.Encoding.Growing.new+              mutable'extensionRange <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO+                                          Data.ProtoLens.Encoding.Growing.new+              mutable'field <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO+                                 Data.ProtoLens.Encoding.Growing.new+              mutable'nestedType <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO+                                      Data.ProtoLens.Encoding.Growing.new+              mutable'oneofDecl <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO+                                     Data.ProtoLens.Encoding.Growing.new+              mutable'reservedName <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO+                                        Data.ProtoLens.Encoding.Growing.new+              mutable'reservedRange <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO+                                         Data.ProtoLens.Encoding.Growing.new+              loop+                Data.ProtoLens.defMessage+                mutable'enumType+                mutable'extension+                mutable'extensionRange+                mutable'field+                mutable'nestedType+                mutable'oneofDecl+                mutable'reservedName+                mutable'reservedRange)+          "DescriptorProto"+  buildMessage+    = \ _x+        -> (Data.Monoid.<>)+             (case+                  Lens.Family2.view (Data.ProtoLens.Field.field @"maybe'name") _x+              of+                Prelude.Nothing -> Data.Monoid.mempty+                (Prelude.Just _v)+                  -> (Data.Monoid.<>)+                       (Data.ProtoLens.Encoding.Bytes.putVarInt 10)+                       ((Prelude..)+                          (\ bs+                             -> (Data.Monoid.<>)+                                  (Data.ProtoLens.Encoding.Bytes.putVarInt+                                     (Prelude.fromIntegral (Data.ByteString.length bs)))+                                  (Data.ProtoLens.Encoding.Bytes.putBytes bs))+                          Data.Text.Encoding.encodeUtf8+                          _v))+             ((Data.Monoid.<>)+                (Data.ProtoLens.Encoding.Bytes.foldMapBuilder+                   (\ _v+                      -> (Data.Monoid.<>)+                           (Data.ProtoLens.Encoding.Bytes.putVarInt 18)+                           ((Prelude..)+                              (\ bs+                                 -> (Data.Monoid.<>)+                                      (Data.ProtoLens.Encoding.Bytes.putVarInt+                                         (Prelude.fromIntegral (Data.ByteString.length bs)))+                                      (Data.ProtoLens.Encoding.Bytes.putBytes bs))+                              Data.ProtoLens.encodeMessage+                              _v))+                   (Lens.Family2.view (Data.ProtoLens.Field.field @"vec'field") _x))+                ((Data.Monoid.<>)+                   (Data.ProtoLens.Encoding.Bytes.foldMapBuilder+                      (\ _v+                         -> (Data.Monoid.<>)+                              (Data.ProtoLens.Encoding.Bytes.putVarInt 50)+                              ((Prelude..)+                                 (\ bs+                                    -> (Data.Monoid.<>)+                                         (Data.ProtoLens.Encoding.Bytes.putVarInt+                                            (Prelude.fromIntegral (Data.ByteString.length bs)))+                                         (Data.ProtoLens.Encoding.Bytes.putBytes bs))+                                 Data.ProtoLens.encodeMessage+                                 _v))+                      (Lens.Family2.view+                         (Data.ProtoLens.Field.field @"vec'extension") _x))+                   ((Data.Monoid.<>)+                      (Data.ProtoLens.Encoding.Bytes.foldMapBuilder+                         (\ _v+                            -> (Data.Monoid.<>)+                                 (Data.ProtoLens.Encoding.Bytes.putVarInt 26)+                                 ((Prelude..)+                                    (\ bs+                                       -> (Data.Monoid.<>)+                                            (Data.ProtoLens.Encoding.Bytes.putVarInt+                                               (Prelude.fromIntegral (Data.ByteString.length bs)))+                                            (Data.ProtoLens.Encoding.Bytes.putBytes bs))+                                    Data.ProtoLens.encodeMessage+                                    _v))+                         (Lens.Family2.view+                            (Data.ProtoLens.Field.field @"vec'nestedType") _x))+                      ((Data.Monoid.<>)+                         (Data.ProtoLens.Encoding.Bytes.foldMapBuilder+                            (\ _v+                               -> (Data.Monoid.<>)+                                    (Data.ProtoLens.Encoding.Bytes.putVarInt 34)+                                    ((Prelude..)+                                       (\ bs+                                          -> (Data.Monoid.<>)+                                               (Data.ProtoLens.Encoding.Bytes.putVarInt+                                                  (Prelude.fromIntegral+                                                     (Data.ByteString.length bs)))+                                               (Data.ProtoLens.Encoding.Bytes.putBytes bs))+                                       Data.ProtoLens.encodeMessage+                                       _v))+                            (Lens.Family2.view+                               (Data.ProtoLens.Field.field @"vec'enumType") _x))+                         ((Data.Monoid.<>)+                            (Data.ProtoLens.Encoding.Bytes.foldMapBuilder+                               (\ _v+                                  -> (Data.Monoid.<>)+                                       (Data.ProtoLens.Encoding.Bytes.putVarInt 42)+                                       ((Prelude..)+                                          (\ bs+                                             -> (Data.Monoid.<>)+                                                  (Data.ProtoLens.Encoding.Bytes.putVarInt+                                                     (Prelude.fromIntegral+                                                        (Data.ByteString.length bs)))+                                                  (Data.ProtoLens.Encoding.Bytes.putBytes bs))+                                          Data.ProtoLens.encodeMessage+                                          _v))+                               (Lens.Family2.view+                                  (Data.ProtoLens.Field.field @"vec'extensionRange") _x))+                            ((Data.Monoid.<>)+                               (Data.ProtoLens.Encoding.Bytes.foldMapBuilder+                                  (\ _v+                                     -> (Data.Monoid.<>)+                                          (Data.ProtoLens.Encoding.Bytes.putVarInt 66)+                                          ((Prelude..)+                                             (\ bs+                                                -> (Data.Monoid.<>)+                                                     (Data.ProtoLens.Encoding.Bytes.putVarInt+                                                        (Prelude.fromIntegral+                                                           (Data.ByteString.length bs)))+                                                     (Data.ProtoLens.Encoding.Bytes.putBytes bs))+                                             Data.ProtoLens.encodeMessage+                                             _v))+                                  (Lens.Family2.view+                                     (Data.ProtoLens.Field.field @"vec'oneofDecl") _x))+                               ((Data.Monoid.<>)+                                  (case+                                       Lens.Family2.view+                                         (Data.ProtoLens.Field.field @"maybe'options") _x+                                   of+                                     Prelude.Nothing -> Data.Monoid.mempty+                                     (Prelude.Just _v)+                                       -> (Data.Monoid.<>)+                                            (Data.ProtoLens.Encoding.Bytes.putVarInt 58)+                                            ((Prelude..)+                                               (\ bs+                                                  -> (Data.Monoid.<>)+                                                       (Data.ProtoLens.Encoding.Bytes.putVarInt+                                                          (Prelude.fromIntegral+                                                             (Data.ByteString.length bs)))+                                                       (Data.ProtoLens.Encoding.Bytes.putBytes bs))+                                               Data.ProtoLens.encodeMessage+                                               _v))+                                  ((Data.Monoid.<>)+                                     (Data.ProtoLens.Encoding.Bytes.foldMapBuilder+                                        (\ _v+                                           -> (Data.Monoid.<>)+                                                (Data.ProtoLens.Encoding.Bytes.putVarInt 74)+                                                ((Prelude..)+                                                   (\ bs+                                                      -> (Data.Monoid.<>)+                                                           (Data.ProtoLens.Encoding.Bytes.putVarInt+                                                              (Prelude.fromIntegral+                                                                 (Data.ByteString.length bs)))+                                                           (Data.ProtoLens.Encoding.Bytes.putBytes+                                                              bs))+                                                   Data.ProtoLens.encodeMessage+                                                   _v))+                                        (Lens.Family2.view+                                           (Data.ProtoLens.Field.field @"vec'reservedRange") _x))+                                     ((Data.Monoid.<>)+                                        (Data.ProtoLens.Encoding.Bytes.foldMapBuilder+                                           (\ _v+                                              -> (Data.Monoid.<>)+                                                   (Data.ProtoLens.Encoding.Bytes.putVarInt 82)+                                                   ((Prelude..)+                                                      (\ bs+                                                         -> (Data.Monoid.<>)+                                                              (Data.ProtoLens.Encoding.Bytes.putVarInt+                                                                 (Prelude.fromIntegral+                                                                    (Data.ByteString.length bs)))+                                                              (Data.ProtoLens.Encoding.Bytes.putBytes+                                                                 bs))+                                                      Data.Text.Encoding.encodeUtf8+                                                      _v))+                                           (Lens.Family2.view+                                              (Data.ProtoLens.Field.field @"vec'reservedName") _x))+                                        (Data.ProtoLens.Encoding.Wire.buildFieldSet+                                           (Lens.Family2.view+                                              Data.ProtoLens.unknownFields _x)))))))))))+instance Control.DeepSeq.NFData DescriptorProto where+  rnf+    = \ x__+        -> Control.DeepSeq.deepseq+             (_DescriptorProto'_unknownFields x__)+             (Control.DeepSeq.deepseq+                (_DescriptorProto'name x__)+                (Control.DeepSeq.deepseq+                   (_DescriptorProto'field x__)+                   (Control.DeepSeq.deepseq+                      (_DescriptorProto'extension x__)+                      (Control.DeepSeq.deepseq+                         (_DescriptorProto'nestedType x__)+                         (Control.DeepSeq.deepseq+                            (_DescriptorProto'enumType x__)+                            (Control.DeepSeq.deepseq+                               (_DescriptorProto'extensionRange x__)+                               (Control.DeepSeq.deepseq+                                  (_DescriptorProto'oneofDecl x__)+                                  (Control.DeepSeq.deepseq+                                     (_DescriptorProto'options x__)+                                     (Control.DeepSeq.deepseq+                                        (_DescriptorProto'reservedRange x__)+                                        (Control.DeepSeq.deepseq+                                           (_DescriptorProto'reservedName x__) ()))))))))))+{- | Fields :+     +         * 'Proto.Google.Protobuf.Descriptor_Fields.start' @:: Lens' DescriptorProto'ExtensionRange Data.Int.Int32@+         * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'start' @:: Lens' DescriptorProto'ExtensionRange (Prelude.Maybe Data.Int.Int32)@+         * 'Proto.Google.Protobuf.Descriptor_Fields.end' @:: Lens' DescriptorProto'ExtensionRange Data.Int.Int32@+         * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'end' @:: Lens' DescriptorProto'ExtensionRange (Prelude.Maybe Data.Int.Int32)@+         * 'Proto.Google.Protobuf.Descriptor_Fields.options' @:: Lens' DescriptorProto'ExtensionRange ExtensionRangeOptions@+         * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'options' @:: Lens' DescriptorProto'ExtensionRange (Prelude.Maybe ExtensionRangeOptions)@ -}+data DescriptorProto'ExtensionRange+  = DescriptorProto'ExtensionRange'_constructor {_DescriptorProto'ExtensionRange'start :: !(Prelude.Maybe Data.Int.Int32),+                                                 _DescriptorProto'ExtensionRange'end :: !(Prelude.Maybe Data.Int.Int32),+                                                 _DescriptorProto'ExtensionRange'options :: !(Prelude.Maybe ExtensionRangeOptions),+                                                 _DescriptorProto'ExtensionRange'_unknownFields :: !Data.ProtoLens.FieldSet}+  deriving (Prelude.Eq, Prelude.Ord)+instance Prelude.Show DescriptorProto'ExtensionRange where+  showsPrec _ __x __s+    = Prelude.showChar+        '{'+        (Prelude.showString+           (Data.ProtoLens.showMessageShort __x) (Prelude.showChar '}' __s))+instance Data.ProtoLens.Field.HasField DescriptorProto'ExtensionRange "start" Data.Int.Int32 where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _DescriptorProto'ExtensionRange'start+           (\ x__ y__ -> x__ {_DescriptorProto'ExtensionRange'start = y__}))+        (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault)+instance Data.ProtoLens.Field.HasField DescriptorProto'ExtensionRange "maybe'start" (Prelude.Maybe Data.Int.Int32) where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _DescriptorProto'ExtensionRange'start+           (\ x__ y__ -> x__ {_DescriptorProto'ExtensionRange'start = y__}))+        Prelude.id+instance Data.ProtoLens.Field.HasField DescriptorProto'ExtensionRange "end" Data.Int.Int32 where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _DescriptorProto'ExtensionRange'end+           (\ x__ y__ -> x__ {_DescriptorProto'ExtensionRange'end = y__}))+        (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault)+instance Data.ProtoLens.Field.HasField DescriptorProto'ExtensionRange "maybe'end" (Prelude.Maybe Data.Int.Int32) where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _DescriptorProto'ExtensionRange'end+           (\ x__ y__ -> x__ {_DescriptorProto'ExtensionRange'end = y__}))+        Prelude.id+instance Data.ProtoLens.Field.HasField DescriptorProto'ExtensionRange "options" ExtensionRangeOptions where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _DescriptorProto'ExtensionRange'options+           (\ x__ y__ -> x__ {_DescriptorProto'ExtensionRange'options = y__}))+        (Data.ProtoLens.maybeLens Data.ProtoLens.defMessage)+instance Data.ProtoLens.Field.HasField DescriptorProto'ExtensionRange "maybe'options" (Prelude.Maybe ExtensionRangeOptions) where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _DescriptorProto'ExtensionRange'options+           (\ x__ y__ -> x__ {_DescriptorProto'ExtensionRange'options = y__}))+        Prelude.id+instance Data.ProtoLens.Message DescriptorProto'ExtensionRange where+  messageName _+    = Data.Text.pack "google.protobuf.DescriptorProto.ExtensionRange"+  fieldsByTag+    = let+        start__field_descriptor+          = Data.ProtoLens.FieldDescriptor+              "start"+              (Data.ProtoLens.ScalarField Data.ProtoLens.Int32Field ::+                 Data.ProtoLens.FieldTypeDescriptor Data.Int.Int32)+              (Data.ProtoLens.OptionalField+                 (Data.ProtoLens.Field.field @"maybe'start")) ::+              Data.ProtoLens.FieldDescriptor DescriptorProto'ExtensionRange+        end__field_descriptor+          = Data.ProtoLens.FieldDescriptor+              "end"+              (Data.ProtoLens.ScalarField Data.ProtoLens.Int32Field ::+                 Data.ProtoLens.FieldTypeDescriptor Data.Int.Int32)+              (Data.ProtoLens.OptionalField+                 (Data.ProtoLens.Field.field @"maybe'end")) ::+              Data.ProtoLens.FieldDescriptor DescriptorProto'ExtensionRange+        options__field_descriptor+          = Data.ProtoLens.FieldDescriptor+              "options"+              (Data.ProtoLens.MessageField Data.ProtoLens.MessageType ::+                 Data.ProtoLens.FieldTypeDescriptor ExtensionRangeOptions)+              (Data.ProtoLens.OptionalField+                 (Data.ProtoLens.Field.field @"maybe'options")) ::+              Data.ProtoLens.FieldDescriptor DescriptorProto'ExtensionRange+      in+        Data.Map.fromList+          [(Data.ProtoLens.Tag 1, start__field_descriptor),+           (Data.ProtoLens.Tag 2, end__field_descriptor),+           (Data.ProtoLens.Tag 3, options__field_descriptor)]+  unknownFields+    = Lens.Family2.Unchecked.lens+        _DescriptorProto'ExtensionRange'_unknownFields+        (\ x__ y__+           -> x__ {_DescriptorProto'ExtensionRange'_unknownFields = y__})+  defMessage+    = DescriptorProto'ExtensionRange'_constructor+        {_DescriptorProto'ExtensionRange'start = Prelude.Nothing,+         _DescriptorProto'ExtensionRange'end = Prelude.Nothing,+         _DescriptorProto'ExtensionRange'options = Prelude.Nothing,+         _DescriptorProto'ExtensionRange'_unknownFields = []}+  parseMessage+    = let+        loop ::+          DescriptorProto'ExtensionRange+          -> Data.ProtoLens.Encoding.Bytes.Parser DescriptorProto'ExtensionRange+        loop x+          = do end <- Data.ProtoLens.Encoding.Bytes.atEnd+               if end then+                   do (let missing = []+                       in+                         if Prelude.null missing then+                             Prelude.return ()+                         else+                             Prelude.fail+                               ((Prelude.++)+                                  "Missing required fields: "+                                  (Prelude.show (missing :: [Prelude.String]))))+                      Prelude.return+                        (Lens.Family2.over+                           Data.ProtoLens.unknownFields (\ !t -> Prelude.reverse t) x)+               else+                   do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt+                      case tag of+                        8 -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)+                                       (Prelude.fmap+                                          Prelude.fromIntegral+                                          Data.ProtoLens.Encoding.Bytes.getVarInt)+                                       "start"+                                loop (Lens.Family2.set (Data.ProtoLens.Field.field @"start") y x)+                        16+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)+                                       (Prelude.fmap+                                          Prelude.fromIntegral+                                          Data.ProtoLens.Encoding.Bytes.getVarInt)+                                       "end"+                                loop (Lens.Family2.set (Data.ProtoLens.Field.field @"end") y x)+                        26+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)+                                       (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt+                                           Data.ProtoLens.Encoding.Bytes.isolate+                                             (Prelude.fromIntegral len) Data.ProtoLens.parseMessage)+                                       "options"+                                loop (Lens.Family2.set (Data.ProtoLens.Field.field @"options") y x)+                        wire+                          -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire+                                        wire+                                loop+                                  (Lens.Family2.over+                                     Data.ProtoLens.unknownFields (\ !t -> (:) y t) x)+      in+        (Data.ProtoLens.Encoding.Bytes.<?>)+          (do loop Data.ProtoLens.defMessage) "ExtensionRange"+  buildMessage+    = \ _x+        -> (Data.Monoid.<>)+             (case+                  Lens.Family2.view (Data.ProtoLens.Field.field @"maybe'start") _x+              of+                Prelude.Nothing -> Data.Monoid.mempty+                (Prelude.Just _v)+                  -> (Data.Monoid.<>)+                       (Data.ProtoLens.Encoding.Bytes.putVarInt 8)+                       ((Prelude..)+                          Data.ProtoLens.Encoding.Bytes.putVarInt Prelude.fromIntegral _v))+             ((Data.Monoid.<>)+                (case+                     Lens.Family2.view (Data.ProtoLens.Field.field @"maybe'end") _x+                 of+                   Prelude.Nothing -> Data.Monoid.mempty+                   (Prelude.Just _v)+                     -> (Data.Monoid.<>)+                          (Data.ProtoLens.Encoding.Bytes.putVarInt 16)+                          ((Prelude..)+                             Data.ProtoLens.Encoding.Bytes.putVarInt Prelude.fromIntegral _v))+                ((Data.Monoid.<>)+                   (case+                        Lens.Family2.view (Data.ProtoLens.Field.field @"maybe'options") _x+                    of+                      Prelude.Nothing -> Data.Monoid.mempty+                      (Prelude.Just _v)+                        -> (Data.Monoid.<>)+                             (Data.ProtoLens.Encoding.Bytes.putVarInt 26)+                             ((Prelude..)+                                (\ bs+                                   -> (Data.Monoid.<>)+                                        (Data.ProtoLens.Encoding.Bytes.putVarInt+                                           (Prelude.fromIntegral (Data.ByteString.length bs)))+                                        (Data.ProtoLens.Encoding.Bytes.putBytes bs))+                                Data.ProtoLens.encodeMessage+                                _v))+                   (Data.ProtoLens.Encoding.Wire.buildFieldSet+                      (Lens.Family2.view Data.ProtoLens.unknownFields _x))))+instance Control.DeepSeq.NFData DescriptorProto'ExtensionRange where+  rnf+    = \ x__+        -> Control.DeepSeq.deepseq+             (_DescriptorProto'ExtensionRange'_unknownFields x__)+             (Control.DeepSeq.deepseq+                (_DescriptorProto'ExtensionRange'start x__)+                (Control.DeepSeq.deepseq+                   (_DescriptorProto'ExtensionRange'end x__)+                   (Control.DeepSeq.deepseq+                      (_DescriptorProto'ExtensionRange'options x__) ())))+{- | Fields :+     +         * 'Proto.Google.Protobuf.Descriptor_Fields.start' @:: Lens' DescriptorProto'ReservedRange Data.Int.Int32@+         * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'start' @:: Lens' DescriptorProto'ReservedRange (Prelude.Maybe Data.Int.Int32)@+         * 'Proto.Google.Protobuf.Descriptor_Fields.end' @:: Lens' DescriptorProto'ReservedRange Data.Int.Int32@+         * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'end' @:: Lens' DescriptorProto'ReservedRange (Prelude.Maybe Data.Int.Int32)@ -}+data DescriptorProto'ReservedRange+  = DescriptorProto'ReservedRange'_constructor {_DescriptorProto'ReservedRange'start :: !(Prelude.Maybe Data.Int.Int32),+                                                _DescriptorProto'ReservedRange'end :: !(Prelude.Maybe Data.Int.Int32),+                                                _DescriptorProto'ReservedRange'_unknownFields :: !Data.ProtoLens.FieldSet}+  deriving (Prelude.Eq, Prelude.Ord)+instance Prelude.Show DescriptorProto'ReservedRange where+  showsPrec _ __x __s+    = Prelude.showChar+        '{'+        (Prelude.showString+           (Data.ProtoLens.showMessageShort __x) (Prelude.showChar '}' __s))+instance Data.ProtoLens.Field.HasField DescriptorProto'ReservedRange "start" Data.Int.Int32 where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _DescriptorProto'ReservedRange'start+           (\ x__ y__ -> x__ {_DescriptorProto'ReservedRange'start = y__}))+        (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault)+instance Data.ProtoLens.Field.HasField DescriptorProto'ReservedRange "maybe'start" (Prelude.Maybe Data.Int.Int32) where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _DescriptorProto'ReservedRange'start+           (\ x__ y__ -> x__ {_DescriptorProto'ReservedRange'start = y__}))+        Prelude.id+instance Data.ProtoLens.Field.HasField DescriptorProto'ReservedRange "end" Data.Int.Int32 where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _DescriptorProto'ReservedRange'end+           (\ x__ y__ -> x__ {_DescriptorProto'ReservedRange'end = y__}))+        (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault)+instance Data.ProtoLens.Field.HasField DescriptorProto'ReservedRange "maybe'end" (Prelude.Maybe Data.Int.Int32) where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _DescriptorProto'ReservedRange'end+           (\ x__ y__ -> x__ {_DescriptorProto'ReservedRange'end = y__}))+        Prelude.id+instance Data.ProtoLens.Message DescriptorProto'ReservedRange where+  messageName _+    = Data.Text.pack "google.protobuf.DescriptorProto.ReservedRange"+  fieldsByTag+    = let+        start__field_descriptor+          = Data.ProtoLens.FieldDescriptor+              "start"+              (Data.ProtoLens.ScalarField Data.ProtoLens.Int32Field ::+                 Data.ProtoLens.FieldTypeDescriptor Data.Int.Int32)+              (Data.ProtoLens.OptionalField+                 (Data.ProtoLens.Field.field @"maybe'start")) ::+              Data.ProtoLens.FieldDescriptor DescriptorProto'ReservedRange+        end__field_descriptor+          = Data.ProtoLens.FieldDescriptor+              "end"+              (Data.ProtoLens.ScalarField Data.ProtoLens.Int32Field ::+                 Data.ProtoLens.FieldTypeDescriptor Data.Int.Int32)+              (Data.ProtoLens.OptionalField+                 (Data.ProtoLens.Field.field @"maybe'end")) ::+              Data.ProtoLens.FieldDescriptor DescriptorProto'ReservedRange+      in+        Data.Map.fromList+          [(Data.ProtoLens.Tag 1, start__field_descriptor),+           (Data.ProtoLens.Tag 2, end__field_descriptor)]+  unknownFields+    = Lens.Family2.Unchecked.lens+        _DescriptorProto'ReservedRange'_unknownFields+        (\ x__ y__+           -> x__ {_DescriptorProto'ReservedRange'_unknownFields = y__})+  defMessage+    = DescriptorProto'ReservedRange'_constructor+        {_DescriptorProto'ReservedRange'start = Prelude.Nothing,+         _DescriptorProto'ReservedRange'end = Prelude.Nothing,+         _DescriptorProto'ReservedRange'_unknownFields = []}+  parseMessage+    = let+        loop ::+          DescriptorProto'ReservedRange+          -> Data.ProtoLens.Encoding.Bytes.Parser DescriptorProto'ReservedRange+        loop x+          = do end <- Data.ProtoLens.Encoding.Bytes.atEnd+               if end then+                   do (let missing = []+                       in+                         if Prelude.null missing then+                             Prelude.return ()+                         else+                             Prelude.fail+                               ((Prelude.++)+                                  "Missing required fields: "+                                  (Prelude.show (missing :: [Prelude.String]))))+                      Prelude.return+                        (Lens.Family2.over+                           Data.ProtoLens.unknownFields (\ !t -> Prelude.reverse t) x)+               else+                   do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt+                      case tag of+                        8 -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)+                                       (Prelude.fmap+                                          Prelude.fromIntegral+                                          Data.ProtoLens.Encoding.Bytes.getVarInt)+                                       "start"+                                loop (Lens.Family2.set (Data.ProtoLens.Field.field @"start") y x)+                        16+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)+                                       (Prelude.fmap+                                          Prelude.fromIntegral+                                          Data.ProtoLens.Encoding.Bytes.getVarInt)+                                       "end"+                                loop (Lens.Family2.set (Data.ProtoLens.Field.field @"end") y x)+                        wire+                          -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire+                                        wire+                                loop+                                  (Lens.Family2.over+                                     Data.ProtoLens.unknownFields (\ !t -> (:) y t) x)+      in+        (Data.ProtoLens.Encoding.Bytes.<?>)+          (do loop Data.ProtoLens.defMessage) "ReservedRange"+  buildMessage+    = \ _x+        -> (Data.Monoid.<>)+             (case+                  Lens.Family2.view (Data.ProtoLens.Field.field @"maybe'start") _x+              of+                Prelude.Nothing -> Data.Monoid.mempty+                (Prelude.Just _v)+                  -> (Data.Monoid.<>)+                       (Data.ProtoLens.Encoding.Bytes.putVarInt 8)+                       ((Prelude..)+                          Data.ProtoLens.Encoding.Bytes.putVarInt Prelude.fromIntegral _v))+             ((Data.Monoid.<>)+                (case+                     Lens.Family2.view (Data.ProtoLens.Field.field @"maybe'end") _x+                 of+                   Prelude.Nothing -> Data.Monoid.mempty+                   (Prelude.Just _v)+                     -> (Data.Monoid.<>)+                          (Data.ProtoLens.Encoding.Bytes.putVarInt 16)+                          ((Prelude..)+                             Data.ProtoLens.Encoding.Bytes.putVarInt Prelude.fromIntegral _v))+                (Data.ProtoLens.Encoding.Wire.buildFieldSet+                   (Lens.Family2.view Data.ProtoLens.unknownFields _x)))+instance Control.DeepSeq.NFData DescriptorProto'ReservedRange where+  rnf+    = \ x__+        -> Control.DeepSeq.deepseq+             (_DescriptorProto'ReservedRange'_unknownFields x__)+             (Control.DeepSeq.deepseq+                (_DescriptorProto'ReservedRange'start x__)+                (Control.DeepSeq.deepseq+                   (_DescriptorProto'ReservedRange'end x__) ()))+{- | Fields :+     +         * 'Proto.Google.Protobuf.Descriptor_Fields.name' @:: Lens' EnumDescriptorProto Data.Text.Text@+         * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'name' @:: Lens' EnumDescriptorProto (Prelude.Maybe Data.Text.Text)@+         * 'Proto.Google.Protobuf.Descriptor_Fields.value' @:: Lens' EnumDescriptorProto [EnumValueDescriptorProto]@+         * 'Proto.Google.Protobuf.Descriptor_Fields.vec'value' @:: Lens' EnumDescriptorProto (Data.Vector.Vector EnumValueDescriptorProto)@+         * 'Proto.Google.Protobuf.Descriptor_Fields.options' @:: Lens' EnumDescriptorProto EnumOptions@+         * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'options' @:: Lens' EnumDescriptorProto (Prelude.Maybe EnumOptions)@+         * 'Proto.Google.Protobuf.Descriptor_Fields.reservedRange' @:: Lens' EnumDescriptorProto [EnumDescriptorProto'EnumReservedRange]@+         * 'Proto.Google.Protobuf.Descriptor_Fields.vec'reservedRange' @:: Lens' EnumDescriptorProto (Data.Vector.Vector EnumDescriptorProto'EnumReservedRange)@+         * 'Proto.Google.Protobuf.Descriptor_Fields.reservedName' @:: Lens' EnumDescriptorProto [Data.Text.Text]@+         * 'Proto.Google.Protobuf.Descriptor_Fields.vec'reservedName' @:: Lens' EnumDescriptorProto (Data.Vector.Vector Data.Text.Text)@ -}+data EnumDescriptorProto+  = EnumDescriptorProto'_constructor {_EnumDescriptorProto'name :: !(Prelude.Maybe Data.Text.Text),+                                      _EnumDescriptorProto'value :: !(Data.Vector.Vector EnumValueDescriptorProto),+                                      _EnumDescriptorProto'options :: !(Prelude.Maybe EnumOptions),+                                      _EnumDescriptorProto'reservedRange :: !(Data.Vector.Vector EnumDescriptorProto'EnumReservedRange),+                                      _EnumDescriptorProto'reservedName :: !(Data.Vector.Vector Data.Text.Text),+                                      _EnumDescriptorProto'_unknownFields :: !Data.ProtoLens.FieldSet}+  deriving (Prelude.Eq, Prelude.Ord)+instance Prelude.Show EnumDescriptorProto where+  showsPrec _ __x __s+    = Prelude.showChar+        '{'+        (Prelude.showString+           (Data.ProtoLens.showMessageShort __x) (Prelude.showChar '}' __s))+instance Data.ProtoLens.Field.HasField EnumDescriptorProto "name" Data.Text.Text where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _EnumDescriptorProto'name+           (\ x__ y__ -> x__ {_EnumDescriptorProto'name = y__}))+        (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault)+instance Data.ProtoLens.Field.HasField EnumDescriptorProto "maybe'name" (Prelude.Maybe Data.Text.Text) where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _EnumDescriptorProto'name+           (\ x__ y__ -> x__ {_EnumDescriptorProto'name = y__}))+        Prelude.id+instance Data.ProtoLens.Field.HasField EnumDescriptorProto "value" [EnumValueDescriptorProto] where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _EnumDescriptorProto'value+           (\ x__ y__ -> x__ {_EnumDescriptorProto'value = y__}))+        (Lens.Family2.Unchecked.lens+           Data.Vector.Generic.toList+           (\ _ y__ -> Data.Vector.Generic.fromList y__))+instance Data.ProtoLens.Field.HasField EnumDescriptorProto "vec'value" (Data.Vector.Vector EnumValueDescriptorProto) where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _EnumDescriptorProto'value+           (\ x__ y__ -> x__ {_EnumDescriptorProto'value = y__}))+        Prelude.id+instance Data.ProtoLens.Field.HasField EnumDescriptorProto "options" EnumOptions where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _EnumDescriptorProto'options+           (\ x__ y__ -> x__ {_EnumDescriptorProto'options = y__}))+        (Data.ProtoLens.maybeLens Data.ProtoLens.defMessage)+instance Data.ProtoLens.Field.HasField EnumDescriptorProto "maybe'options" (Prelude.Maybe EnumOptions) where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _EnumDescriptorProto'options+           (\ x__ y__ -> x__ {_EnumDescriptorProto'options = y__}))+        Prelude.id+instance Data.ProtoLens.Field.HasField EnumDescriptorProto "reservedRange" [EnumDescriptorProto'EnumReservedRange] where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _EnumDescriptorProto'reservedRange+           (\ x__ y__ -> x__ {_EnumDescriptorProto'reservedRange = y__}))+        (Lens.Family2.Unchecked.lens+           Data.Vector.Generic.toList+           (\ _ y__ -> Data.Vector.Generic.fromList y__))+instance Data.ProtoLens.Field.HasField EnumDescriptorProto "vec'reservedRange" (Data.Vector.Vector EnumDescriptorProto'EnumReservedRange) where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _EnumDescriptorProto'reservedRange+           (\ x__ y__ -> x__ {_EnumDescriptorProto'reservedRange = y__}))+        Prelude.id+instance Data.ProtoLens.Field.HasField EnumDescriptorProto "reservedName" [Data.Text.Text] where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _EnumDescriptorProto'reservedName+           (\ x__ y__ -> x__ {_EnumDescriptorProto'reservedName = y__}))+        (Lens.Family2.Unchecked.lens+           Data.Vector.Generic.toList+           (\ _ y__ -> Data.Vector.Generic.fromList y__))+instance Data.ProtoLens.Field.HasField EnumDescriptorProto "vec'reservedName" (Data.Vector.Vector Data.Text.Text) where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _EnumDescriptorProto'reservedName+           (\ x__ y__ -> x__ {_EnumDescriptorProto'reservedName = y__}))+        Prelude.id+instance Data.ProtoLens.Message EnumDescriptorProto where+  messageName _+    = Data.Text.pack "google.protobuf.EnumDescriptorProto"+  fieldsByTag+    = let+        name__field_descriptor+          = Data.ProtoLens.FieldDescriptor+              "name"+              (Data.ProtoLens.ScalarField Data.ProtoLens.StringField ::+                 Data.ProtoLens.FieldTypeDescriptor Data.Text.Text)+              (Data.ProtoLens.OptionalField+                 (Data.ProtoLens.Field.field @"maybe'name")) ::+              Data.ProtoLens.FieldDescriptor EnumDescriptorProto+        value__field_descriptor+          = Data.ProtoLens.FieldDescriptor+              "value"+              (Data.ProtoLens.MessageField Data.ProtoLens.MessageType ::+                 Data.ProtoLens.FieldTypeDescriptor EnumValueDescriptorProto)+              (Data.ProtoLens.RepeatedField+                 Data.ProtoLens.Unpacked (Data.ProtoLens.Field.field @"value")) ::+              Data.ProtoLens.FieldDescriptor EnumDescriptorProto+        options__field_descriptor+          = Data.ProtoLens.FieldDescriptor+              "options"+              (Data.ProtoLens.MessageField Data.ProtoLens.MessageType ::+                 Data.ProtoLens.FieldTypeDescriptor EnumOptions)+              (Data.ProtoLens.OptionalField+                 (Data.ProtoLens.Field.field @"maybe'options")) ::+              Data.ProtoLens.FieldDescriptor EnumDescriptorProto+        reservedRange__field_descriptor+          = Data.ProtoLens.FieldDescriptor+              "reserved_range"+              (Data.ProtoLens.MessageField Data.ProtoLens.MessageType ::+                 Data.ProtoLens.FieldTypeDescriptor EnumDescriptorProto'EnumReservedRange)+              (Data.ProtoLens.RepeatedField+                 Data.ProtoLens.Unpacked+                 (Data.ProtoLens.Field.field @"reservedRange")) ::+              Data.ProtoLens.FieldDescriptor EnumDescriptorProto+        reservedName__field_descriptor+          = Data.ProtoLens.FieldDescriptor+              "reserved_name"+              (Data.ProtoLens.ScalarField Data.ProtoLens.StringField ::+                 Data.ProtoLens.FieldTypeDescriptor Data.Text.Text)+              (Data.ProtoLens.RepeatedField+                 Data.ProtoLens.Unpacked+                 (Data.ProtoLens.Field.field @"reservedName")) ::+              Data.ProtoLens.FieldDescriptor EnumDescriptorProto+      in+        Data.Map.fromList+          [(Data.ProtoLens.Tag 1, name__field_descriptor),+           (Data.ProtoLens.Tag 2, value__field_descriptor),+           (Data.ProtoLens.Tag 3, options__field_descriptor),+           (Data.ProtoLens.Tag 4, reservedRange__field_descriptor),+           (Data.ProtoLens.Tag 5, reservedName__field_descriptor)]+  unknownFields+    = Lens.Family2.Unchecked.lens+        _EnumDescriptorProto'_unknownFields+        (\ x__ y__ -> x__ {_EnumDescriptorProto'_unknownFields = y__})+  defMessage+    = EnumDescriptorProto'_constructor+        {_EnumDescriptorProto'name = Prelude.Nothing,+         _EnumDescriptorProto'value = Data.Vector.Generic.empty,+         _EnumDescriptorProto'options = Prelude.Nothing,+         _EnumDescriptorProto'reservedRange = Data.Vector.Generic.empty,+         _EnumDescriptorProto'reservedName = Data.Vector.Generic.empty,+         _EnumDescriptorProto'_unknownFields = []}+  parseMessage+    = let+        loop ::+          EnumDescriptorProto+          -> Data.ProtoLens.Encoding.Growing.Growing Data.Vector.Vector Data.ProtoLens.Encoding.Growing.RealWorld Data.Text.Text+             -> Data.ProtoLens.Encoding.Growing.Growing Data.Vector.Vector Data.ProtoLens.Encoding.Growing.RealWorld EnumDescriptorProto'EnumReservedRange+                -> Data.ProtoLens.Encoding.Growing.Growing Data.Vector.Vector Data.ProtoLens.Encoding.Growing.RealWorld EnumValueDescriptorProto+                   -> Data.ProtoLens.Encoding.Bytes.Parser EnumDescriptorProto+        loop x mutable'reservedName mutable'reservedRange mutable'value+          = do end <- Data.ProtoLens.Encoding.Bytes.atEnd+               if end then+                   do frozen'reservedName <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO+                                               (Data.ProtoLens.Encoding.Growing.unsafeFreeze+                                                  mutable'reservedName)+                      frozen'reservedRange <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO+                                                (Data.ProtoLens.Encoding.Growing.unsafeFreeze+                                                   mutable'reservedRange)+                      frozen'value <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO+                                        (Data.ProtoLens.Encoding.Growing.unsafeFreeze mutable'value)+                      (let missing = []+                       in+                         if Prelude.null missing then+                             Prelude.return ()+                         else+                             Prelude.fail+                               ((Prelude.++)+                                  "Missing required fields: "+                                  (Prelude.show (missing :: [Prelude.String]))))+                      Prelude.return+                        (Lens.Family2.over+                           Data.ProtoLens.unknownFields+                           (\ !t -> Prelude.reverse t)+                           (Lens.Family2.set+                              (Data.ProtoLens.Field.field @"vec'reservedName")+                              frozen'reservedName+                              (Lens.Family2.set+                                 (Data.ProtoLens.Field.field @"vec'reservedRange")+                                 frozen'reservedRange+                                 (Lens.Family2.set+                                    (Data.ProtoLens.Field.field @"vec'value") frozen'value x))))+               else+                   do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt+                      case tag of+                        10+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)+                                       (do value <- do len <- Data.ProtoLens.Encoding.Bytes.getVarInt+                                                       Data.ProtoLens.Encoding.Bytes.getBytes+                                                         (Prelude.fromIntegral len)+                                           Data.ProtoLens.Encoding.Bytes.runEither+                                             (case Data.Text.Encoding.decodeUtf8' value of+                                                (Prelude.Left err)+                                                  -> Prelude.Left (Prelude.show err)+                                                (Prelude.Right r) -> Prelude.Right r))+                                       "name"+                                loop+                                  (Lens.Family2.set (Data.ProtoLens.Field.field @"name") y x)+                                  mutable'reservedName+                                  mutable'reservedRange+                                  mutable'value+                        18+                          -> do !y <- (Data.ProtoLens.Encoding.Bytes.<?>)+                                        (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt+                                            Data.ProtoLens.Encoding.Bytes.isolate+                                              (Prelude.fromIntegral len)+                                              Data.ProtoLens.parseMessage)+                                        "value"+                                v <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO+                                       (Data.ProtoLens.Encoding.Growing.append mutable'value y)+                                loop x mutable'reservedName mutable'reservedRange v+                        26+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)+                                       (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt+                                           Data.ProtoLens.Encoding.Bytes.isolate+                                             (Prelude.fromIntegral len) Data.ProtoLens.parseMessage)+                                       "options"+                                loop+                                  (Lens.Family2.set (Data.ProtoLens.Field.field @"options") y x)+                                  mutable'reservedName+                                  mutable'reservedRange+                                  mutable'value+                        34+                          -> do !y <- (Data.ProtoLens.Encoding.Bytes.<?>)+                                        (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt+                                            Data.ProtoLens.Encoding.Bytes.isolate+                                              (Prelude.fromIntegral len)+                                              Data.ProtoLens.parseMessage)+                                        "reserved_range"+                                v <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO+                                       (Data.ProtoLens.Encoding.Growing.append+                                          mutable'reservedRange y)+                                loop x mutable'reservedName v mutable'value+                        42+                          -> do !y <- (Data.ProtoLens.Encoding.Bytes.<?>)+                                        (do value <- do len <- Data.ProtoLens.Encoding.Bytes.getVarInt+                                                        Data.ProtoLens.Encoding.Bytes.getBytes+                                                          (Prelude.fromIntegral len)+                                            Data.ProtoLens.Encoding.Bytes.runEither+                                              (case Data.Text.Encoding.decodeUtf8' value of+                                                 (Prelude.Left err)+                                                   -> Prelude.Left (Prelude.show err)+                                                 (Prelude.Right r) -> Prelude.Right r))+                                        "reserved_name"+                                v <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO+                                       (Data.ProtoLens.Encoding.Growing.append+                                          mutable'reservedName y)+                                loop x v mutable'reservedRange mutable'value+                        wire+                          -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire+                                        wire+                                loop+                                  (Lens.Family2.over+                                     Data.ProtoLens.unknownFields (\ !t -> (:) y t) x)+                                  mutable'reservedName+                                  mutable'reservedRange+                                  mutable'value+      in+        (Data.ProtoLens.Encoding.Bytes.<?>)+          (do mutable'reservedName <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO+                                        Data.ProtoLens.Encoding.Growing.new+              mutable'reservedRange <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO+                                         Data.ProtoLens.Encoding.Growing.new+              mutable'value <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO+                                 Data.ProtoLens.Encoding.Growing.new+              loop+                Data.ProtoLens.defMessage+                mutable'reservedName+                mutable'reservedRange+                mutable'value)+          "EnumDescriptorProto"+  buildMessage+    = \ _x+        -> (Data.Monoid.<>)+             (case+                  Lens.Family2.view (Data.ProtoLens.Field.field @"maybe'name") _x+              of+                Prelude.Nothing -> Data.Monoid.mempty+                (Prelude.Just _v)+                  -> (Data.Monoid.<>)+                       (Data.ProtoLens.Encoding.Bytes.putVarInt 10)+                       ((Prelude..)+                          (\ bs+                             -> (Data.Monoid.<>)+                                  (Data.ProtoLens.Encoding.Bytes.putVarInt+                                     (Prelude.fromIntegral (Data.ByteString.length bs)))+                                  (Data.ProtoLens.Encoding.Bytes.putBytes bs))+                          Data.Text.Encoding.encodeUtf8+                          _v))+             ((Data.Monoid.<>)+                (Data.ProtoLens.Encoding.Bytes.foldMapBuilder+                   (\ _v+                      -> (Data.Monoid.<>)+                           (Data.ProtoLens.Encoding.Bytes.putVarInt 18)+                           ((Prelude..)+                              (\ bs+                                 -> (Data.Monoid.<>)+                                      (Data.ProtoLens.Encoding.Bytes.putVarInt+                                         (Prelude.fromIntegral (Data.ByteString.length bs)))+                                      (Data.ProtoLens.Encoding.Bytes.putBytes bs))+                              Data.ProtoLens.encodeMessage+                              _v))+                   (Lens.Family2.view (Data.ProtoLens.Field.field @"vec'value") _x))+                ((Data.Monoid.<>)+                   (case+                        Lens.Family2.view (Data.ProtoLens.Field.field @"maybe'options") _x+                    of+                      Prelude.Nothing -> Data.Monoid.mempty+                      (Prelude.Just _v)+                        -> (Data.Monoid.<>)+                             (Data.ProtoLens.Encoding.Bytes.putVarInt 26)+                             ((Prelude..)+                                (\ bs+                                   -> (Data.Monoid.<>)+                                        (Data.ProtoLens.Encoding.Bytes.putVarInt+                                           (Prelude.fromIntegral (Data.ByteString.length bs)))+                                        (Data.ProtoLens.Encoding.Bytes.putBytes bs))+                                Data.ProtoLens.encodeMessage+                                _v))+                   ((Data.Monoid.<>)+                      (Data.ProtoLens.Encoding.Bytes.foldMapBuilder+                         (\ _v+                            -> (Data.Monoid.<>)+                                 (Data.ProtoLens.Encoding.Bytes.putVarInt 34)+                                 ((Prelude..)+                                    (\ bs+                                       -> (Data.Monoid.<>)+                                            (Data.ProtoLens.Encoding.Bytes.putVarInt+                                               (Prelude.fromIntegral (Data.ByteString.length bs)))+                                            (Data.ProtoLens.Encoding.Bytes.putBytes bs))+                                    Data.ProtoLens.encodeMessage+                                    _v))+                         (Lens.Family2.view+                            (Data.ProtoLens.Field.field @"vec'reservedRange") _x))+                      ((Data.Monoid.<>)+                         (Data.ProtoLens.Encoding.Bytes.foldMapBuilder+                            (\ _v+                               -> (Data.Monoid.<>)+                                    (Data.ProtoLens.Encoding.Bytes.putVarInt 42)+                                    ((Prelude..)+                                       (\ bs+                                          -> (Data.Monoid.<>)+                                               (Data.ProtoLens.Encoding.Bytes.putVarInt+                                                  (Prelude.fromIntegral+                                                     (Data.ByteString.length bs)))+                                               (Data.ProtoLens.Encoding.Bytes.putBytes bs))+                                       Data.Text.Encoding.encodeUtf8+                                       _v))+                            (Lens.Family2.view+                               (Data.ProtoLens.Field.field @"vec'reservedName") _x))+                         (Data.ProtoLens.Encoding.Wire.buildFieldSet+                            (Lens.Family2.view Data.ProtoLens.unknownFields _x))))))+instance Control.DeepSeq.NFData EnumDescriptorProto where+  rnf+    = \ x__+        -> Control.DeepSeq.deepseq+             (_EnumDescriptorProto'_unknownFields x__)+             (Control.DeepSeq.deepseq+                (_EnumDescriptorProto'name x__)+                (Control.DeepSeq.deepseq+                   (_EnumDescriptorProto'value x__)+                   (Control.DeepSeq.deepseq+                      (_EnumDescriptorProto'options x__)+                      (Control.DeepSeq.deepseq+                         (_EnumDescriptorProto'reservedRange x__)+                         (Control.DeepSeq.deepseq+                            (_EnumDescriptorProto'reservedName x__) ())))))+{- | Fields :+     +         * 'Proto.Google.Protobuf.Descriptor_Fields.start' @:: Lens' EnumDescriptorProto'EnumReservedRange Data.Int.Int32@+         * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'start' @:: Lens' EnumDescriptorProto'EnumReservedRange (Prelude.Maybe Data.Int.Int32)@+         * 'Proto.Google.Protobuf.Descriptor_Fields.end' @:: Lens' EnumDescriptorProto'EnumReservedRange Data.Int.Int32@+         * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'end' @:: Lens' EnumDescriptorProto'EnumReservedRange (Prelude.Maybe Data.Int.Int32)@ -}+data EnumDescriptorProto'EnumReservedRange+  = EnumDescriptorProto'EnumReservedRange'_constructor {_EnumDescriptorProto'EnumReservedRange'start :: !(Prelude.Maybe Data.Int.Int32),+                                                        _EnumDescriptorProto'EnumReservedRange'end :: !(Prelude.Maybe Data.Int.Int32),+                                                        _EnumDescriptorProto'EnumReservedRange'_unknownFields :: !Data.ProtoLens.FieldSet}+  deriving (Prelude.Eq, Prelude.Ord)+instance Prelude.Show EnumDescriptorProto'EnumReservedRange where+  showsPrec _ __x __s+    = Prelude.showChar+        '{'+        (Prelude.showString+           (Data.ProtoLens.showMessageShort __x) (Prelude.showChar '}' __s))+instance Data.ProtoLens.Field.HasField EnumDescriptorProto'EnumReservedRange "start" Data.Int.Int32 where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _EnumDescriptorProto'EnumReservedRange'start+           (\ x__ y__+              -> x__ {_EnumDescriptorProto'EnumReservedRange'start = y__}))+        (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault)+instance Data.ProtoLens.Field.HasField EnumDescriptorProto'EnumReservedRange "maybe'start" (Prelude.Maybe Data.Int.Int32) where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _EnumDescriptorProto'EnumReservedRange'start+           (\ x__ y__+              -> x__ {_EnumDescriptorProto'EnumReservedRange'start = y__}))+        Prelude.id+instance Data.ProtoLens.Field.HasField EnumDescriptorProto'EnumReservedRange "end" Data.Int.Int32 where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _EnumDescriptorProto'EnumReservedRange'end+           (\ x__ y__+              -> x__ {_EnumDescriptorProto'EnumReservedRange'end = y__}))+        (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault)+instance Data.ProtoLens.Field.HasField EnumDescriptorProto'EnumReservedRange "maybe'end" (Prelude.Maybe Data.Int.Int32) where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _EnumDescriptorProto'EnumReservedRange'end+           (\ x__ y__+              -> x__ {_EnumDescriptorProto'EnumReservedRange'end = y__}))+        Prelude.id+instance Data.ProtoLens.Message EnumDescriptorProto'EnumReservedRange where+  messageName _+    = Data.Text.pack+        "google.protobuf.EnumDescriptorProto.EnumReservedRange"+  fieldsByTag+    = let+        start__field_descriptor+          = Data.ProtoLens.FieldDescriptor+              "start"+              (Data.ProtoLens.ScalarField Data.ProtoLens.Int32Field ::+                 Data.ProtoLens.FieldTypeDescriptor Data.Int.Int32)+              (Data.ProtoLens.OptionalField+                 (Data.ProtoLens.Field.field @"maybe'start")) ::+              Data.ProtoLens.FieldDescriptor EnumDescriptorProto'EnumReservedRange+        end__field_descriptor+          = Data.ProtoLens.FieldDescriptor+              "end"+              (Data.ProtoLens.ScalarField Data.ProtoLens.Int32Field ::+                 Data.ProtoLens.FieldTypeDescriptor Data.Int.Int32)+              (Data.ProtoLens.OptionalField+                 (Data.ProtoLens.Field.field @"maybe'end")) ::+              Data.ProtoLens.FieldDescriptor EnumDescriptorProto'EnumReservedRange+      in+        Data.Map.fromList+          [(Data.ProtoLens.Tag 1, start__field_descriptor),+           (Data.ProtoLens.Tag 2, end__field_descriptor)]+  unknownFields+    = Lens.Family2.Unchecked.lens+        _EnumDescriptorProto'EnumReservedRange'_unknownFields+        (\ x__ y__+           -> x__+                {_EnumDescriptorProto'EnumReservedRange'_unknownFields = y__})+  defMessage+    = EnumDescriptorProto'EnumReservedRange'_constructor+        {_EnumDescriptorProto'EnumReservedRange'start = Prelude.Nothing,+         _EnumDescriptorProto'EnumReservedRange'end = Prelude.Nothing,+         _EnumDescriptorProto'EnumReservedRange'_unknownFields = []}+  parseMessage+    = let+        loop ::+          EnumDescriptorProto'EnumReservedRange+          -> Data.ProtoLens.Encoding.Bytes.Parser EnumDescriptorProto'EnumReservedRange+        loop x+          = do end <- Data.ProtoLens.Encoding.Bytes.atEnd+               if end then+                   do (let missing = []+                       in+                         if Prelude.null missing then+                             Prelude.return ()+                         else+                             Prelude.fail+                               ((Prelude.++)+                                  "Missing required fields: "+                                  (Prelude.show (missing :: [Prelude.String]))))+                      Prelude.return+                        (Lens.Family2.over+                           Data.ProtoLens.unknownFields (\ !t -> Prelude.reverse t) x)+               else+                   do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt+                      case tag of+                        8 -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)+                                       (Prelude.fmap+                                          Prelude.fromIntegral+                                          Data.ProtoLens.Encoding.Bytes.getVarInt)+                                       "start"+                                loop (Lens.Family2.set (Data.ProtoLens.Field.field @"start") y x)+                        16+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)+                                       (Prelude.fmap+                                          Prelude.fromIntegral+                                          Data.ProtoLens.Encoding.Bytes.getVarInt)+                                       "end"+                                loop (Lens.Family2.set (Data.ProtoLens.Field.field @"end") y x)+                        wire+                          -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire+                                        wire+                                loop+                                  (Lens.Family2.over+                                     Data.ProtoLens.unknownFields (\ !t -> (:) y t) x)+      in+        (Data.ProtoLens.Encoding.Bytes.<?>)+          (do loop Data.ProtoLens.defMessage) "EnumReservedRange"+  buildMessage+    = \ _x+        -> (Data.Monoid.<>)+             (case+                  Lens.Family2.view (Data.ProtoLens.Field.field @"maybe'start") _x+              of+                Prelude.Nothing -> Data.Monoid.mempty+                (Prelude.Just _v)+                  -> (Data.Monoid.<>)+                       (Data.ProtoLens.Encoding.Bytes.putVarInt 8)+                       ((Prelude..)+                          Data.ProtoLens.Encoding.Bytes.putVarInt Prelude.fromIntegral _v))+             ((Data.Monoid.<>)+                (case+                     Lens.Family2.view (Data.ProtoLens.Field.field @"maybe'end") _x+                 of+                   Prelude.Nothing -> Data.Monoid.mempty+                   (Prelude.Just _v)+                     -> (Data.Monoid.<>)+                          (Data.ProtoLens.Encoding.Bytes.putVarInt 16)+                          ((Prelude..)+                             Data.ProtoLens.Encoding.Bytes.putVarInt Prelude.fromIntegral _v))+                (Data.ProtoLens.Encoding.Wire.buildFieldSet+                   (Lens.Family2.view Data.ProtoLens.unknownFields _x)))+instance Control.DeepSeq.NFData EnumDescriptorProto'EnumReservedRange where+  rnf+    = \ x__+        -> Control.DeepSeq.deepseq+             (_EnumDescriptorProto'EnumReservedRange'_unknownFields x__)+             (Control.DeepSeq.deepseq+                (_EnumDescriptorProto'EnumReservedRange'start x__)+                (Control.DeepSeq.deepseq+                   (_EnumDescriptorProto'EnumReservedRange'end x__) ()))+{- | Fields :+     +         * 'Proto.Google.Protobuf.Descriptor_Fields.allowAlias' @:: Lens' EnumOptions Prelude.Bool@+         * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'allowAlias' @:: Lens' EnumOptions (Prelude.Maybe Prelude.Bool)@+         * 'Proto.Google.Protobuf.Descriptor_Fields.deprecated' @:: Lens' EnumOptions Prelude.Bool@+         * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'deprecated' @:: Lens' EnumOptions (Prelude.Maybe Prelude.Bool)@+         * 'Proto.Google.Protobuf.Descriptor_Fields.uninterpretedOption' @:: Lens' EnumOptions [UninterpretedOption]@+         * 'Proto.Google.Protobuf.Descriptor_Fields.vec'uninterpretedOption' @:: Lens' EnumOptions (Data.Vector.Vector UninterpretedOption)@ -}+data EnumOptions+  = EnumOptions'_constructor {_EnumOptions'allowAlias :: !(Prelude.Maybe Prelude.Bool),+                              _EnumOptions'deprecated :: !(Prelude.Maybe Prelude.Bool),+                              _EnumOptions'uninterpretedOption :: !(Data.Vector.Vector UninterpretedOption),+                              _EnumOptions'_unknownFields :: !Data.ProtoLens.FieldSet}+  deriving (Prelude.Eq, Prelude.Ord)+instance Prelude.Show EnumOptions where+  showsPrec _ __x __s+    = Prelude.showChar+        '{'+        (Prelude.showString+           (Data.ProtoLens.showMessageShort __x) (Prelude.showChar '}' __s))+instance Data.ProtoLens.Field.HasField EnumOptions "allowAlias" Prelude.Bool where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _EnumOptions'allowAlias+           (\ x__ y__ -> x__ {_EnumOptions'allowAlias = y__}))+        (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault)+instance Data.ProtoLens.Field.HasField EnumOptions "maybe'allowAlias" (Prelude.Maybe Prelude.Bool) where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _EnumOptions'allowAlias+           (\ x__ y__ -> x__ {_EnumOptions'allowAlias = y__}))+        Prelude.id+instance Data.ProtoLens.Field.HasField EnumOptions "deprecated" Prelude.Bool where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _EnumOptions'deprecated+           (\ x__ y__ -> x__ {_EnumOptions'deprecated = y__}))+        (Data.ProtoLens.maybeLens Prelude.False)+instance Data.ProtoLens.Field.HasField EnumOptions "maybe'deprecated" (Prelude.Maybe Prelude.Bool) where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _EnumOptions'deprecated+           (\ x__ y__ -> x__ {_EnumOptions'deprecated = y__}))+        Prelude.id+instance Data.ProtoLens.Field.HasField EnumOptions "uninterpretedOption" [UninterpretedOption] where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _EnumOptions'uninterpretedOption+           (\ x__ y__ -> x__ {_EnumOptions'uninterpretedOption = y__}))+        (Lens.Family2.Unchecked.lens+           Data.Vector.Generic.toList+           (\ _ y__ -> Data.Vector.Generic.fromList y__))+instance Data.ProtoLens.Field.HasField EnumOptions "vec'uninterpretedOption" (Data.Vector.Vector UninterpretedOption) where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _EnumOptions'uninterpretedOption+           (\ x__ y__ -> x__ {_EnumOptions'uninterpretedOption = y__}))+        Prelude.id+instance Data.ProtoLens.Message EnumOptions where+  messageName _ = Data.Text.pack "google.protobuf.EnumOptions"+  fieldsByTag+    = let+        allowAlias__field_descriptor+          = Data.ProtoLens.FieldDescriptor+              "allow_alias"+              (Data.ProtoLens.ScalarField Data.ProtoLens.BoolField ::+                 Data.ProtoLens.FieldTypeDescriptor Prelude.Bool)+              (Data.ProtoLens.OptionalField+                 (Data.ProtoLens.Field.field @"maybe'allowAlias")) ::+              Data.ProtoLens.FieldDescriptor EnumOptions+        deprecated__field_descriptor+          = Data.ProtoLens.FieldDescriptor+              "deprecated"+              (Data.ProtoLens.ScalarField Data.ProtoLens.BoolField ::+                 Data.ProtoLens.FieldTypeDescriptor Prelude.Bool)+              (Data.ProtoLens.OptionalField+                 (Data.ProtoLens.Field.field @"maybe'deprecated")) ::+              Data.ProtoLens.FieldDescriptor EnumOptions+        uninterpretedOption__field_descriptor+          = Data.ProtoLens.FieldDescriptor+              "uninterpreted_option"+              (Data.ProtoLens.MessageField Data.ProtoLens.MessageType ::+                 Data.ProtoLens.FieldTypeDescriptor UninterpretedOption)+              (Data.ProtoLens.RepeatedField+                 Data.ProtoLens.Unpacked+                 (Data.ProtoLens.Field.field @"uninterpretedOption")) ::+              Data.ProtoLens.FieldDescriptor EnumOptions+      in+        Data.Map.fromList+          [(Data.ProtoLens.Tag 2, allowAlias__field_descriptor),+           (Data.ProtoLens.Tag 3, deprecated__field_descriptor),+           (Data.ProtoLens.Tag 999, uninterpretedOption__field_descriptor)]+  unknownFields+    = Lens.Family2.Unchecked.lens+        _EnumOptions'_unknownFields+        (\ x__ y__ -> x__ {_EnumOptions'_unknownFields = y__})+  defMessage+    = EnumOptions'_constructor+        {_EnumOptions'allowAlias = Prelude.Nothing,+         _EnumOptions'deprecated = Prelude.Nothing,+         _EnumOptions'uninterpretedOption = Data.Vector.Generic.empty,+         _EnumOptions'_unknownFields = []}+  parseMessage+    = let+        loop ::+          EnumOptions+          -> Data.ProtoLens.Encoding.Growing.Growing Data.Vector.Vector Data.ProtoLens.Encoding.Growing.RealWorld UninterpretedOption+             -> Data.ProtoLens.Encoding.Bytes.Parser EnumOptions+        loop x mutable'uninterpretedOption+          = do end <- Data.ProtoLens.Encoding.Bytes.atEnd+               if end then+                   do frozen'uninterpretedOption <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO+                                                      (Data.ProtoLens.Encoding.Growing.unsafeFreeze+                                                         mutable'uninterpretedOption)+                      (let missing = []+                       in+                         if Prelude.null missing then+                             Prelude.return ()+                         else+                             Prelude.fail+                               ((Prelude.++)+                                  "Missing required fields: "+                                  (Prelude.show (missing :: [Prelude.String]))))+                      Prelude.return+                        (Lens.Family2.over+                           Data.ProtoLens.unknownFields+                           (\ !t -> Prelude.reverse t)+                           (Lens.Family2.set+                              (Data.ProtoLens.Field.field @"vec'uninterpretedOption")+                              frozen'uninterpretedOption+                              x))+               else+                   do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt+                      case tag of+                        16+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)+                                       (Prelude.fmap+                                          ((Prelude./=) 0) Data.ProtoLens.Encoding.Bytes.getVarInt)+                                       "allow_alias"+                                loop+                                  (Lens.Family2.set (Data.ProtoLens.Field.field @"allowAlias") y x)+                                  mutable'uninterpretedOption+                        24+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)+                                       (Prelude.fmap+                                          ((Prelude./=) 0) Data.ProtoLens.Encoding.Bytes.getVarInt)+                                       "deprecated"+                                loop+                                  (Lens.Family2.set (Data.ProtoLens.Field.field @"deprecated") y x)+                                  mutable'uninterpretedOption+                        7994+                          -> do !y <- (Data.ProtoLens.Encoding.Bytes.<?>)+                                        (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt+                                            Data.ProtoLens.Encoding.Bytes.isolate+                                              (Prelude.fromIntegral len)+                                              Data.ProtoLens.parseMessage)+                                        "uninterpreted_option"+                                v <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO+                                       (Data.ProtoLens.Encoding.Growing.append+                                          mutable'uninterpretedOption y)+                                loop x v+                        wire+                          -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire+                                        wire+                                loop+                                  (Lens.Family2.over+                                     Data.ProtoLens.unknownFields (\ !t -> (:) y t) x)+                                  mutable'uninterpretedOption+      in+        (Data.ProtoLens.Encoding.Bytes.<?>)+          (do mutable'uninterpretedOption <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO+                                               Data.ProtoLens.Encoding.Growing.new+              loop Data.ProtoLens.defMessage mutable'uninterpretedOption)+          "EnumOptions"+  buildMessage+    = \ _x+        -> (Data.Monoid.<>)+             (case+                  Lens.Family2.view+                    (Data.ProtoLens.Field.field @"maybe'allowAlias") _x+              of+                Prelude.Nothing -> Data.Monoid.mempty+                (Prelude.Just _v)+                  -> (Data.Monoid.<>)+                       (Data.ProtoLens.Encoding.Bytes.putVarInt 16)+                       ((Prelude..)+                          Data.ProtoLens.Encoding.Bytes.putVarInt+                          (\ b -> if b then 1 else 0)+                          _v))+             ((Data.Monoid.<>)+                (case+                     Lens.Family2.view+                       (Data.ProtoLens.Field.field @"maybe'deprecated") _x+                 of+                   Prelude.Nothing -> Data.Monoid.mempty+                   (Prelude.Just _v)+                     -> (Data.Monoid.<>)+                          (Data.ProtoLens.Encoding.Bytes.putVarInt 24)+                          ((Prelude..)+                             Data.ProtoLens.Encoding.Bytes.putVarInt+                             (\ b -> if b then 1 else 0)+                             _v))+                ((Data.Monoid.<>)+                   (Data.ProtoLens.Encoding.Bytes.foldMapBuilder+                      (\ _v+                         -> (Data.Monoid.<>)+                              (Data.ProtoLens.Encoding.Bytes.putVarInt 7994)+                              ((Prelude..)+                                 (\ bs+                                    -> (Data.Monoid.<>)+                                         (Data.ProtoLens.Encoding.Bytes.putVarInt+                                            (Prelude.fromIntegral (Data.ByteString.length bs)))+                                         (Data.ProtoLens.Encoding.Bytes.putBytes bs))+                                 Data.ProtoLens.encodeMessage+                                 _v))+                      (Lens.Family2.view+                         (Data.ProtoLens.Field.field @"vec'uninterpretedOption") _x))+                   (Data.ProtoLens.Encoding.Wire.buildFieldSet+                      (Lens.Family2.view Data.ProtoLens.unknownFields _x))))+instance Control.DeepSeq.NFData EnumOptions where+  rnf+    = \ x__+        -> Control.DeepSeq.deepseq+             (_EnumOptions'_unknownFields x__)+             (Control.DeepSeq.deepseq+                (_EnumOptions'allowAlias x__)+                (Control.DeepSeq.deepseq+                   (_EnumOptions'deprecated x__)+                   (Control.DeepSeq.deepseq+                      (_EnumOptions'uninterpretedOption x__) ())))+{- | Fields :+     +         * 'Proto.Google.Protobuf.Descriptor_Fields.name' @:: Lens' EnumValueDescriptorProto Data.Text.Text@+         * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'name' @:: Lens' EnumValueDescriptorProto (Prelude.Maybe Data.Text.Text)@+         * 'Proto.Google.Protobuf.Descriptor_Fields.number' @:: Lens' EnumValueDescriptorProto Data.Int.Int32@+         * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'number' @:: Lens' EnumValueDescriptorProto (Prelude.Maybe Data.Int.Int32)@+         * 'Proto.Google.Protobuf.Descriptor_Fields.options' @:: Lens' EnumValueDescriptorProto EnumValueOptions@+         * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'options' @:: Lens' EnumValueDescriptorProto (Prelude.Maybe EnumValueOptions)@ -}+data EnumValueDescriptorProto+  = EnumValueDescriptorProto'_constructor {_EnumValueDescriptorProto'name :: !(Prelude.Maybe Data.Text.Text),+                                           _EnumValueDescriptorProto'number :: !(Prelude.Maybe Data.Int.Int32),+                                           _EnumValueDescriptorProto'options :: !(Prelude.Maybe EnumValueOptions),+                                           _EnumValueDescriptorProto'_unknownFields :: !Data.ProtoLens.FieldSet}+  deriving (Prelude.Eq, Prelude.Ord)+instance Prelude.Show EnumValueDescriptorProto where+  showsPrec _ __x __s+    = Prelude.showChar+        '{'+        (Prelude.showString+           (Data.ProtoLens.showMessageShort __x) (Prelude.showChar '}' __s))+instance Data.ProtoLens.Field.HasField EnumValueDescriptorProto "name" Data.Text.Text where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _EnumValueDescriptorProto'name+           (\ x__ y__ -> x__ {_EnumValueDescriptorProto'name = y__}))+        (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault)+instance Data.ProtoLens.Field.HasField EnumValueDescriptorProto "maybe'name" (Prelude.Maybe Data.Text.Text) where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _EnumValueDescriptorProto'name+           (\ x__ y__ -> x__ {_EnumValueDescriptorProto'name = y__}))+        Prelude.id+instance Data.ProtoLens.Field.HasField EnumValueDescriptorProto "number" Data.Int.Int32 where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _EnumValueDescriptorProto'number+           (\ x__ y__ -> x__ {_EnumValueDescriptorProto'number = y__}))+        (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault)+instance Data.ProtoLens.Field.HasField EnumValueDescriptorProto "maybe'number" (Prelude.Maybe Data.Int.Int32) where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _EnumValueDescriptorProto'number+           (\ x__ y__ -> x__ {_EnumValueDescriptorProto'number = y__}))+        Prelude.id+instance Data.ProtoLens.Field.HasField EnumValueDescriptorProto "options" EnumValueOptions where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _EnumValueDescriptorProto'options+           (\ x__ y__ -> x__ {_EnumValueDescriptorProto'options = y__}))+        (Data.ProtoLens.maybeLens Data.ProtoLens.defMessage)+instance Data.ProtoLens.Field.HasField EnumValueDescriptorProto "maybe'options" (Prelude.Maybe EnumValueOptions) where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _EnumValueDescriptorProto'options+           (\ x__ y__ -> x__ {_EnumValueDescriptorProto'options = y__}))+        Prelude.id+instance Data.ProtoLens.Message EnumValueDescriptorProto where+  messageName _+    = Data.Text.pack "google.protobuf.EnumValueDescriptorProto"+  fieldsByTag+    = let+        name__field_descriptor+          = Data.ProtoLens.FieldDescriptor+              "name"+              (Data.ProtoLens.ScalarField Data.ProtoLens.StringField ::+                 Data.ProtoLens.FieldTypeDescriptor Data.Text.Text)+              (Data.ProtoLens.OptionalField+                 (Data.ProtoLens.Field.field @"maybe'name")) ::+              Data.ProtoLens.FieldDescriptor EnumValueDescriptorProto+        number__field_descriptor+          = Data.ProtoLens.FieldDescriptor+              "number"+              (Data.ProtoLens.ScalarField Data.ProtoLens.Int32Field ::+                 Data.ProtoLens.FieldTypeDescriptor Data.Int.Int32)+              (Data.ProtoLens.OptionalField+                 (Data.ProtoLens.Field.field @"maybe'number")) ::+              Data.ProtoLens.FieldDescriptor EnumValueDescriptorProto+        options__field_descriptor+          = Data.ProtoLens.FieldDescriptor+              "options"+              (Data.ProtoLens.MessageField Data.ProtoLens.MessageType ::+                 Data.ProtoLens.FieldTypeDescriptor EnumValueOptions)+              (Data.ProtoLens.OptionalField+                 (Data.ProtoLens.Field.field @"maybe'options")) ::+              Data.ProtoLens.FieldDescriptor EnumValueDescriptorProto+      in+        Data.Map.fromList+          [(Data.ProtoLens.Tag 1, name__field_descriptor),+           (Data.ProtoLens.Tag 2, number__field_descriptor),+           (Data.ProtoLens.Tag 3, options__field_descriptor)]+  unknownFields+    = Lens.Family2.Unchecked.lens+        _EnumValueDescriptorProto'_unknownFields+        (\ x__ y__ -> x__ {_EnumValueDescriptorProto'_unknownFields = y__})+  defMessage+    = EnumValueDescriptorProto'_constructor+        {_EnumValueDescriptorProto'name = Prelude.Nothing,+         _EnumValueDescriptorProto'number = Prelude.Nothing,+         _EnumValueDescriptorProto'options = Prelude.Nothing,+         _EnumValueDescriptorProto'_unknownFields = []}+  parseMessage+    = let+        loop ::+          EnumValueDescriptorProto+          -> Data.ProtoLens.Encoding.Bytes.Parser EnumValueDescriptorProto+        loop x+          = do end <- Data.ProtoLens.Encoding.Bytes.atEnd+               if end then+                   do (let missing = []+                       in+                         if Prelude.null missing then+                             Prelude.return ()+                         else+                             Prelude.fail+                               ((Prelude.++)+                                  "Missing required fields: "+                                  (Prelude.show (missing :: [Prelude.String]))))+                      Prelude.return+                        (Lens.Family2.over+                           Data.ProtoLens.unknownFields (\ !t -> Prelude.reverse t) x)+               else+                   do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt+                      case tag of+                        10+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)+                                       (do value <- do len <- Data.ProtoLens.Encoding.Bytes.getVarInt+                                                       Data.ProtoLens.Encoding.Bytes.getBytes+                                                         (Prelude.fromIntegral len)+                                           Data.ProtoLens.Encoding.Bytes.runEither+                                             (case Data.Text.Encoding.decodeUtf8' value of+                                                (Prelude.Left err)+                                                  -> Prelude.Left (Prelude.show err)+                                                (Prelude.Right r) -> Prelude.Right r))+                                       "name"+                                loop (Lens.Family2.set (Data.ProtoLens.Field.field @"name") y x)+                        16+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)+                                       (Prelude.fmap+                                          Prelude.fromIntegral+                                          Data.ProtoLens.Encoding.Bytes.getVarInt)+                                       "number"+                                loop (Lens.Family2.set (Data.ProtoLens.Field.field @"number") y x)+                        26+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)+                                       (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt+                                           Data.ProtoLens.Encoding.Bytes.isolate+                                             (Prelude.fromIntegral len) Data.ProtoLens.parseMessage)+                                       "options"+                                loop (Lens.Family2.set (Data.ProtoLens.Field.field @"options") y x)+                        wire+                          -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire+                                        wire+                                loop+                                  (Lens.Family2.over+                                     Data.ProtoLens.unknownFields (\ !t -> (:) y t) x)+      in+        (Data.ProtoLens.Encoding.Bytes.<?>)+          (do loop Data.ProtoLens.defMessage) "EnumValueDescriptorProto"+  buildMessage+    = \ _x+        -> (Data.Monoid.<>)+             (case+                  Lens.Family2.view (Data.ProtoLens.Field.field @"maybe'name") _x+              of+                Prelude.Nothing -> Data.Monoid.mempty+                (Prelude.Just _v)+                  -> (Data.Monoid.<>)+                       (Data.ProtoLens.Encoding.Bytes.putVarInt 10)+                       ((Prelude..)+                          (\ bs+                             -> (Data.Monoid.<>)+                                  (Data.ProtoLens.Encoding.Bytes.putVarInt+                                     (Prelude.fromIntegral (Data.ByteString.length bs)))+                                  (Data.ProtoLens.Encoding.Bytes.putBytes bs))+                          Data.Text.Encoding.encodeUtf8+                          _v))+             ((Data.Monoid.<>)+                (case+                     Lens.Family2.view (Data.ProtoLens.Field.field @"maybe'number") _x+                 of+                   Prelude.Nothing -> Data.Monoid.mempty+                   (Prelude.Just _v)+                     -> (Data.Monoid.<>)+                          (Data.ProtoLens.Encoding.Bytes.putVarInt 16)+                          ((Prelude..)+                             Data.ProtoLens.Encoding.Bytes.putVarInt Prelude.fromIntegral _v))+                ((Data.Monoid.<>)+                   (case+                        Lens.Family2.view (Data.ProtoLens.Field.field @"maybe'options") _x+                    of+                      Prelude.Nothing -> Data.Monoid.mempty+                      (Prelude.Just _v)+                        -> (Data.Monoid.<>)+                             (Data.ProtoLens.Encoding.Bytes.putVarInt 26)+                             ((Prelude..)+                                (\ bs+                                   -> (Data.Monoid.<>)+                                        (Data.ProtoLens.Encoding.Bytes.putVarInt+                                           (Prelude.fromIntegral (Data.ByteString.length bs)))+                                        (Data.ProtoLens.Encoding.Bytes.putBytes bs))+                                Data.ProtoLens.encodeMessage+                                _v))+                   (Data.ProtoLens.Encoding.Wire.buildFieldSet+                      (Lens.Family2.view Data.ProtoLens.unknownFields _x))))+instance Control.DeepSeq.NFData EnumValueDescriptorProto where+  rnf+    = \ x__+        -> Control.DeepSeq.deepseq+             (_EnumValueDescriptorProto'_unknownFields x__)+             (Control.DeepSeq.deepseq+                (_EnumValueDescriptorProto'name x__)+                (Control.DeepSeq.deepseq+                   (_EnumValueDescriptorProto'number x__)+                   (Control.DeepSeq.deepseq+                      (_EnumValueDescriptorProto'options x__) ())))+{- | Fields :+     +         * 'Proto.Google.Protobuf.Descriptor_Fields.deprecated' @:: Lens' EnumValueOptions Prelude.Bool@+         * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'deprecated' @:: Lens' EnumValueOptions (Prelude.Maybe Prelude.Bool)@+         * 'Proto.Google.Protobuf.Descriptor_Fields.uninterpretedOption' @:: Lens' EnumValueOptions [UninterpretedOption]@+         * 'Proto.Google.Protobuf.Descriptor_Fields.vec'uninterpretedOption' @:: Lens' EnumValueOptions (Data.Vector.Vector UninterpretedOption)@ -}+data EnumValueOptions+  = EnumValueOptions'_constructor {_EnumValueOptions'deprecated :: !(Prelude.Maybe Prelude.Bool),+                                   _EnumValueOptions'uninterpretedOption :: !(Data.Vector.Vector UninterpretedOption),+                                   _EnumValueOptions'_unknownFields :: !Data.ProtoLens.FieldSet}+  deriving (Prelude.Eq, Prelude.Ord)+instance Prelude.Show EnumValueOptions where+  showsPrec _ __x __s+    = Prelude.showChar+        '{'+        (Prelude.showString+           (Data.ProtoLens.showMessageShort __x) (Prelude.showChar '}' __s))+instance Data.ProtoLens.Field.HasField EnumValueOptions "deprecated" Prelude.Bool where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _EnumValueOptions'deprecated+           (\ x__ y__ -> x__ {_EnumValueOptions'deprecated = y__}))+        (Data.ProtoLens.maybeLens Prelude.False)+instance Data.ProtoLens.Field.HasField EnumValueOptions "maybe'deprecated" (Prelude.Maybe Prelude.Bool) where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _EnumValueOptions'deprecated+           (\ x__ y__ -> x__ {_EnumValueOptions'deprecated = y__}))+        Prelude.id+instance Data.ProtoLens.Field.HasField EnumValueOptions "uninterpretedOption" [UninterpretedOption] where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _EnumValueOptions'uninterpretedOption+           (\ x__ y__ -> x__ {_EnumValueOptions'uninterpretedOption = y__}))+        (Lens.Family2.Unchecked.lens+           Data.Vector.Generic.toList+           (\ _ y__ -> Data.Vector.Generic.fromList y__))+instance Data.ProtoLens.Field.HasField EnumValueOptions "vec'uninterpretedOption" (Data.Vector.Vector UninterpretedOption) where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _EnumValueOptions'uninterpretedOption+           (\ x__ y__ -> x__ {_EnumValueOptions'uninterpretedOption = y__}))+        Prelude.id+instance Data.ProtoLens.Message EnumValueOptions where+  messageName _ = Data.Text.pack "google.protobuf.EnumValueOptions"+  fieldsByTag+    = let+        deprecated__field_descriptor+          = Data.ProtoLens.FieldDescriptor+              "deprecated"+              (Data.ProtoLens.ScalarField Data.ProtoLens.BoolField ::+                 Data.ProtoLens.FieldTypeDescriptor Prelude.Bool)+              (Data.ProtoLens.OptionalField+                 (Data.ProtoLens.Field.field @"maybe'deprecated")) ::+              Data.ProtoLens.FieldDescriptor EnumValueOptions+        uninterpretedOption__field_descriptor+          = Data.ProtoLens.FieldDescriptor+              "uninterpreted_option"+              (Data.ProtoLens.MessageField Data.ProtoLens.MessageType ::+                 Data.ProtoLens.FieldTypeDescriptor UninterpretedOption)+              (Data.ProtoLens.RepeatedField+                 Data.ProtoLens.Unpacked+                 (Data.ProtoLens.Field.field @"uninterpretedOption")) ::+              Data.ProtoLens.FieldDescriptor EnumValueOptions+      in+        Data.Map.fromList+          [(Data.ProtoLens.Tag 1, deprecated__field_descriptor),+           (Data.ProtoLens.Tag 999, uninterpretedOption__field_descriptor)]+  unknownFields+    = Lens.Family2.Unchecked.lens+        _EnumValueOptions'_unknownFields+        (\ x__ y__ -> x__ {_EnumValueOptions'_unknownFields = y__})+  defMessage+    = EnumValueOptions'_constructor+        {_EnumValueOptions'deprecated = Prelude.Nothing,+         _EnumValueOptions'uninterpretedOption = Data.Vector.Generic.empty,+         _EnumValueOptions'_unknownFields = []}+  parseMessage+    = let+        loop ::+          EnumValueOptions+          -> Data.ProtoLens.Encoding.Growing.Growing Data.Vector.Vector Data.ProtoLens.Encoding.Growing.RealWorld UninterpretedOption+             -> Data.ProtoLens.Encoding.Bytes.Parser EnumValueOptions+        loop x mutable'uninterpretedOption+          = do end <- Data.ProtoLens.Encoding.Bytes.atEnd+               if end then+                   do frozen'uninterpretedOption <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO+                                                      (Data.ProtoLens.Encoding.Growing.unsafeFreeze+                                                         mutable'uninterpretedOption)+                      (let missing = []+                       in+                         if Prelude.null missing then+                             Prelude.return ()+                         else+                             Prelude.fail+                               ((Prelude.++)+                                  "Missing required fields: "+                                  (Prelude.show (missing :: [Prelude.String]))))+                      Prelude.return+                        (Lens.Family2.over+                           Data.ProtoLens.unknownFields+                           (\ !t -> Prelude.reverse t)+                           (Lens.Family2.set+                              (Data.ProtoLens.Field.field @"vec'uninterpretedOption")+                              frozen'uninterpretedOption+                              x))+               else+                   do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt+                      case tag of+                        8 -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)+                                       (Prelude.fmap+                                          ((Prelude./=) 0) Data.ProtoLens.Encoding.Bytes.getVarInt)+                                       "deprecated"+                                loop+                                  (Lens.Family2.set (Data.ProtoLens.Field.field @"deprecated") y x)+                                  mutable'uninterpretedOption+                        7994+                          -> do !y <- (Data.ProtoLens.Encoding.Bytes.<?>)+                                        (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt+                                            Data.ProtoLens.Encoding.Bytes.isolate+                                              (Prelude.fromIntegral len)+                                              Data.ProtoLens.parseMessage)+                                        "uninterpreted_option"+                                v <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO+                                       (Data.ProtoLens.Encoding.Growing.append+                                          mutable'uninterpretedOption y)+                                loop x v+                        wire+                          -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire+                                        wire+                                loop+                                  (Lens.Family2.over+                                     Data.ProtoLens.unknownFields (\ !t -> (:) y t) x)+                                  mutable'uninterpretedOption+      in+        (Data.ProtoLens.Encoding.Bytes.<?>)+          (do mutable'uninterpretedOption <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO+                                               Data.ProtoLens.Encoding.Growing.new+              loop Data.ProtoLens.defMessage mutable'uninterpretedOption)+          "EnumValueOptions"+  buildMessage+    = \ _x+        -> (Data.Monoid.<>)+             (case+                  Lens.Family2.view+                    (Data.ProtoLens.Field.field @"maybe'deprecated") _x+              of+                Prelude.Nothing -> Data.Monoid.mempty+                (Prelude.Just _v)+                  -> (Data.Monoid.<>)+                       (Data.ProtoLens.Encoding.Bytes.putVarInt 8)+                       ((Prelude..)+                          Data.ProtoLens.Encoding.Bytes.putVarInt+                          (\ b -> if b then 1 else 0)+                          _v))+             ((Data.Monoid.<>)+                (Data.ProtoLens.Encoding.Bytes.foldMapBuilder+                   (\ _v+                      -> (Data.Monoid.<>)+                           (Data.ProtoLens.Encoding.Bytes.putVarInt 7994)+                           ((Prelude..)+                              (\ bs+                                 -> (Data.Monoid.<>)+                                      (Data.ProtoLens.Encoding.Bytes.putVarInt+                                         (Prelude.fromIntegral (Data.ByteString.length bs)))+                                      (Data.ProtoLens.Encoding.Bytes.putBytes bs))+                              Data.ProtoLens.encodeMessage+                              _v))+                   (Lens.Family2.view+                      (Data.ProtoLens.Field.field @"vec'uninterpretedOption") _x))+                (Data.ProtoLens.Encoding.Wire.buildFieldSet+                   (Lens.Family2.view Data.ProtoLens.unknownFields _x)))+instance Control.DeepSeq.NFData EnumValueOptions where+  rnf+    = \ x__+        -> Control.DeepSeq.deepseq+             (_EnumValueOptions'_unknownFields x__)+             (Control.DeepSeq.deepseq+                (_EnumValueOptions'deprecated x__)+                (Control.DeepSeq.deepseq+                   (_EnumValueOptions'uninterpretedOption x__) ()))+{- | Fields :+     +         * 'Proto.Google.Protobuf.Descriptor_Fields.uninterpretedOption' @:: Lens' ExtensionRangeOptions [UninterpretedOption]@+         * 'Proto.Google.Protobuf.Descriptor_Fields.vec'uninterpretedOption' @:: Lens' ExtensionRangeOptions (Data.Vector.Vector UninterpretedOption)@ -}+data ExtensionRangeOptions+  = ExtensionRangeOptions'_constructor {_ExtensionRangeOptions'uninterpretedOption :: !(Data.Vector.Vector UninterpretedOption),+                                        _ExtensionRangeOptions'_unknownFields :: !Data.ProtoLens.FieldSet}+  deriving (Prelude.Eq, Prelude.Ord)+instance Prelude.Show ExtensionRangeOptions where+  showsPrec _ __x __s+    = Prelude.showChar+        '{'+        (Prelude.showString+           (Data.ProtoLens.showMessageShort __x) (Prelude.showChar '}' __s))+instance Data.ProtoLens.Field.HasField ExtensionRangeOptions "uninterpretedOption" [UninterpretedOption] where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _ExtensionRangeOptions'uninterpretedOption+           (\ x__ y__+              -> x__ {_ExtensionRangeOptions'uninterpretedOption = y__}))+        (Lens.Family2.Unchecked.lens+           Data.Vector.Generic.toList+           (\ _ y__ -> Data.Vector.Generic.fromList y__))+instance Data.ProtoLens.Field.HasField ExtensionRangeOptions "vec'uninterpretedOption" (Data.Vector.Vector UninterpretedOption) where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _ExtensionRangeOptions'uninterpretedOption+           (\ x__ y__+              -> x__ {_ExtensionRangeOptions'uninterpretedOption = y__}))+        Prelude.id+instance Data.ProtoLens.Message ExtensionRangeOptions where+  messageName _+    = Data.Text.pack "google.protobuf.ExtensionRangeOptions"+  fieldsByTag+    = let+        uninterpretedOption__field_descriptor+          = Data.ProtoLens.FieldDescriptor+              "uninterpreted_option"+              (Data.ProtoLens.MessageField Data.ProtoLens.MessageType ::+                 Data.ProtoLens.FieldTypeDescriptor UninterpretedOption)+              (Data.ProtoLens.RepeatedField+                 Data.ProtoLens.Unpacked+                 (Data.ProtoLens.Field.field @"uninterpretedOption")) ::+              Data.ProtoLens.FieldDescriptor ExtensionRangeOptions+      in+        Data.Map.fromList+          [(Data.ProtoLens.Tag 999, uninterpretedOption__field_descriptor)]+  unknownFields+    = Lens.Family2.Unchecked.lens+        _ExtensionRangeOptions'_unknownFields+        (\ x__ y__ -> x__ {_ExtensionRangeOptions'_unknownFields = y__})+  defMessage+    = ExtensionRangeOptions'_constructor+        {_ExtensionRangeOptions'uninterpretedOption = Data.Vector.Generic.empty,+         _ExtensionRangeOptions'_unknownFields = []}+  parseMessage+    = let+        loop ::+          ExtensionRangeOptions+          -> Data.ProtoLens.Encoding.Growing.Growing Data.Vector.Vector Data.ProtoLens.Encoding.Growing.RealWorld UninterpretedOption+             -> Data.ProtoLens.Encoding.Bytes.Parser ExtensionRangeOptions+        loop x mutable'uninterpretedOption+          = do end <- Data.ProtoLens.Encoding.Bytes.atEnd+               if end then+                   do frozen'uninterpretedOption <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO+                                                      (Data.ProtoLens.Encoding.Growing.unsafeFreeze+                                                         mutable'uninterpretedOption)+                      (let missing = []+                       in+                         if Prelude.null missing then+                             Prelude.return ()+                         else+                             Prelude.fail+                               ((Prelude.++)+                                  "Missing required fields: "+                                  (Prelude.show (missing :: [Prelude.String]))))+                      Prelude.return+                        (Lens.Family2.over+                           Data.ProtoLens.unknownFields+                           (\ !t -> Prelude.reverse t)+                           (Lens.Family2.set+                              (Data.ProtoLens.Field.field @"vec'uninterpretedOption")+                              frozen'uninterpretedOption+                              x))+               else+                   do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt+                      case tag of+                        7994+                          -> do !y <- (Data.ProtoLens.Encoding.Bytes.<?>)+                                        (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt+                                            Data.ProtoLens.Encoding.Bytes.isolate+                                              (Prelude.fromIntegral len)+                                              Data.ProtoLens.parseMessage)+                                        "uninterpreted_option"+                                v <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO+                                       (Data.ProtoLens.Encoding.Growing.append+                                          mutable'uninterpretedOption y)+                                loop x v+                        wire+                          -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire+                                        wire+                                loop+                                  (Lens.Family2.over+                                     Data.ProtoLens.unknownFields (\ !t -> (:) y t) x)+                                  mutable'uninterpretedOption+      in+        (Data.ProtoLens.Encoding.Bytes.<?>)+          (do mutable'uninterpretedOption <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO+                                               Data.ProtoLens.Encoding.Growing.new+              loop Data.ProtoLens.defMessage mutable'uninterpretedOption)+          "ExtensionRangeOptions"+  buildMessage+    = \ _x+        -> (Data.Monoid.<>)+             (Data.ProtoLens.Encoding.Bytes.foldMapBuilder+                (\ _v+                   -> (Data.Monoid.<>)+                        (Data.ProtoLens.Encoding.Bytes.putVarInt 7994)+                        ((Prelude..)+                           (\ bs+                              -> (Data.Monoid.<>)+                                   (Data.ProtoLens.Encoding.Bytes.putVarInt+                                      (Prelude.fromIntegral (Data.ByteString.length bs)))+                                   (Data.ProtoLens.Encoding.Bytes.putBytes bs))+                           Data.ProtoLens.encodeMessage+                           _v))+                (Lens.Family2.view+                   (Data.ProtoLens.Field.field @"vec'uninterpretedOption") _x))+             (Data.ProtoLens.Encoding.Wire.buildFieldSet+                (Lens.Family2.view Data.ProtoLens.unknownFields _x))+instance Control.DeepSeq.NFData ExtensionRangeOptions where+  rnf+    = \ x__+        -> Control.DeepSeq.deepseq+             (_ExtensionRangeOptions'_unknownFields x__)+             (Control.DeepSeq.deepseq+                (_ExtensionRangeOptions'uninterpretedOption x__) ())+{- | Fields :+     +         * 'Proto.Google.Protobuf.Descriptor_Fields.name' @:: Lens' FieldDescriptorProto Data.Text.Text@+         * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'name' @:: Lens' FieldDescriptorProto (Prelude.Maybe Data.Text.Text)@+         * 'Proto.Google.Protobuf.Descriptor_Fields.number' @:: Lens' FieldDescriptorProto Data.Int.Int32@+         * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'number' @:: Lens' FieldDescriptorProto (Prelude.Maybe Data.Int.Int32)@+         * 'Proto.Google.Protobuf.Descriptor_Fields.label' @:: Lens' FieldDescriptorProto FieldDescriptorProto'Label@+         * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'label' @:: Lens' FieldDescriptorProto (Prelude.Maybe FieldDescriptorProto'Label)@+         * 'Proto.Google.Protobuf.Descriptor_Fields.type'' @:: Lens' FieldDescriptorProto FieldDescriptorProto'Type@+         * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'type'' @:: Lens' FieldDescriptorProto (Prelude.Maybe FieldDescriptorProto'Type)@+         * 'Proto.Google.Protobuf.Descriptor_Fields.typeName' @:: Lens' FieldDescriptorProto Data.Text.Text@+         * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'typeName' @:: Lens' FieldDescriptorProto (Prelude.Maybe Data.Text.Text)@+         * 'Proto.Google.Protobuf.Descriptor_Fields.extendee' @:: Lens' FieldDescriptorProto Data.Text.Text@+         * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'extendee' @:: Lens' FieldDescriptorProto (Prelude.Maybe Data.Text.Text)@+         * 'Proto.Google.Protobuf.Descriptor_Fields.defaultValue' @:: Lens' FieldDescriptorProto Data.Text.Text@+         * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'defaultValue' @:: Lens' FieldDescriptorProto (Prelude.Maybe Data.Text.Text)@+         * 'Proto.Google.Protobuf.Descriptor_Fields.oneofIndex' @:: Lens' FieldDescriptorProto Data.Int.Int32@+         * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'oneofIndex' @:: Lens' FieldDescriptorProto (Prelude.Maybe Data.Int.Int32)@+         * 'Proto.Google.Protobuf.Descriptor_Fields.jsonName' @:: Lens' FieldDescriptorProto Data.Text.Text@+         * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'jsonName' @:: Lens' FieldDescriptorProto (Prelude.Maybe Data.Text.Text)@+         * 'Proto.Google.Protobuf.Descriptor_Fields.options' @:: Lens' FieldDescriptorProto FieldOptions@+         * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'options' @:: Lens' FieldDescriptorProto (Prelude.Maybe FieldOptions)@ -}+data FieldDescriptorProto+  = FieldDescriptorProto'_constructor {_FieldDescriptorProto'name :: !(Prelude.Maybe Data.Text.Text),+                                       _FieldDescriptorProto'number :: !(Prelude.Maybe Data.Int.Int32),+                                       _FieldDescriptorProto'label :: !(Prelude.Maybe FieldDescriptorProto'Label),+                                       _FieldDescriptorProto'type' :: !(Prelude.Maybe FieldDescriptorProto'Type),+                                       _FieldDescriptorProto'typeName :: !(Prelude.Maybe Data.Text.Text),+                                       _FieldDescriptorProto'extendee :: !(Prelude.Maybe Data.Text.Text),+                                       _FieldDescriptorProto'defaultValue :: !(Prelude.Maybe Data.Text.Text),+                                       _FieldDescriptorProto'oneofIndex :: !(Prelude.Maybe Data.Int.Int32),+                                       _FieldDescriptorProto'jsonName :: !(Prelude.Maybe Data.Text.Text),+                                       _FieldDescriptorProto'options :: !(Prelude.Maybe FieldOptions),+                                       _FieldDescriptorProto'_unknownFields :: !Data.ProtoLens.FieldSet}+  deriving (Prelude.Eq, Prelude.Ord)+instance Prelude.Show FieldDescriptorProto where+  showsPrec _ __x __s+    = Prelude.showChar+        '{'+        (Prelude.showString+           (Data.ProtoLens.showMessageShort __x) (Prelude.showChar '}' __s))+instance Data.ProtoLens.Field.HasField FieldDescriptorProto "name" Data.Text.Text where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _FieldDescriptorProto'name+           (\ x__ y__ -> x__ {_FieldDescriptorProto'name = y__}))+        (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault)+instance Data.ProtoLens.Field.HasField FieldDescriptorProto "maybe'name" (Prelude.Maybe Data.Text.Text) where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _FieldDescriptorProto'name+           (\ x__ y__ -> x__ {_FieldDescriptorProto'name = y__}))+        Prelude.id+instance Data.ProtoLens.Field.HasField FieldDescriptorProto "number" Data.Int.Int32 where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _FieldDescriptorProto'number+           (\ x__ y__ -> x__ {_FieldDescriptorProto'number = y__}))+        (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault)+instance Data.ProtoLens.Field.HasField FieldDescriptorProto "maybe'number" (Prelude.Maybe Data.Int.Int32) where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _FieldDescriptorProto'number+           (\ x__ y__ -> x__ {_FieldDescriptorProto'number = y__}))+        Prelude.id+instance Data.ProtoLens.Field.HasField FieldDescriptorProto "label" FieldDescriptorProto'Label where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _FieldDescriptorProto'label+           (\ x__ y__ -> x__ {_FieldDescriptorProto'label = y__}))+        (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault)+instance Data.ProtoLens.Field.HasField FieldDescriptorProto "maybe'label" (Prelude.Maybe FieldDescriptorProto'Label) where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _FieldDescriptorProto'label+           (\ x__ y__ -> x__ {_FieldDescriptorProto'label = y__}))+        Prelude.id+instance Data.ProtoLens.Field.HasField FieldDescriptorProto "type'" FieldDescriptorProto'Type where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _FieldDescriptorProto'type'+           (\ x__ y__ -> x__ {_FieldDescriptorProto'type' = y__}))+        (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault)+instance Data.ProtoLens.Field.HasField FieldDescriptorProto "maybe'type'" (Prelude.Maybe FieldDescriptorProto'Type) where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _FieldDescriptorProto'type'+           (\ x__ y__ -> x__ {_FieldDescriptorProto'type' = y__}))+        Prelude.id+instance Data.ProtoLens.Field.HasField FieldDescriptorProto "typeName" Data.Text.Text where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _FieldDescriptorProto'typeName+           (\ x__ y__ -> x__ {_FieldDescriptorProto'typeName = y__}))+        (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault)+instance Data.ProtoLens.Field.HasField FieldDescriptorProto "maybe'typeName" (Prelude.Maybe Data.Text.Text) where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _FieldDescriptorProto'typeName+           (\ x__ y__ -> x__ {_FieldDescriptorProto'typeName = y__}))+        Prelude.id+instance Data.ProtoLens.Field.HasField FieldDescriptorProto "extendee" Data.Text.Text where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _FieldDescriptorProto'extendee+           (\ x__ y__ -> x__ {_FieldDescriptorProto'extendee = y__}))+        (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault)+instance Data.ProtoLens.Field.HasField FieldDescriptorProto "maybe'extendee" (Prelude.Maybe Data.Text.Text) where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _FieldDescriptorProto'extendee+           (\ x__ y__ -> x__ {_FieldDescriptorProto'extendee = y__}))+        Prelude.id+instance Data.ProtoLens.Field.HasField FieldDescriptorProto "defaultValue" Data.Text.Text where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _FieldDescriptorProto'defaultValue+           (\ x__ y__ -> x__ {_FieldDescriptorProto'defaultValue = y__}))+        (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault)+instance Data.ProtoLens.Field.HasField FieldDescriptorProto "maybe'defaultValue" (Prelude.Maybe Data.Text.Text) where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _FieldDescriptorProto'defaultValue+           (\ x__ y__ -> x__ {_FieldDescriptorProto'defaultValue = y__}))+        Prelude.id+instance Data.ProtoLens.Field.HasField FieldDescriptorProto "oneofIndex" Data.Int.Int32 where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _FieldDescriptorProto'oneofIndex+           (\ x__ y__ -> x__ {_FieldDescriptorProto'oneofIndex = y__}))+        (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault)+instance Data.ProtoLens.Field.HasField FieldDescriptorProto "maybe'oneofIndex" (Prelude.Maybe Data.Int.Int32) where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _FieldDescriptorProto'oneofIndex+           (\ x__ y__ -> x__ {_FieldDescriptorProto'oneofIndex = y__}))+        Prelude.id+instance Data.ProtoLens.Field.HasField FieldDescriptorProto "jsonName" Data.Text.Text where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _FieldDescriptorProto'jsonName+           (\ x__ y__ -> x__ {_FieldDescriptorProto'jsonName = y__}))+        (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault)+instance Data.ProtoLens.Field.HasField FieldDescriptorProto "maybe'jsonName" (Prelude.Maybe Data.Text.Text) where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _FieldDescriptorProto'jsonName+           (\ x__ y__ -> x__ {_FieldDescriptorProto'jsonName = y__}))+        Prelude.id+instance Data.ProtoLens.Field.HasField FieldDescriptorProto "options" FieldOptions where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _FieldDescriptorProto'options+           (\ x__ y__ -> x__ {_FieldDescriptorProto'options = y__}))+        (Data.ProtoLens.maybeLens Data.ProtoLens.defMessage)+instance Data.ProtoLens.Field.HasField FieldDescriptorProto "maybe'options" (Prelude.Maybe FieldOptions) where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _FieldDescriptorProto'options+           (\ x__ y__ -> x__ {_FieldDescriptorProto'options = y__}))+        Prelude.id+instance Data.ProtoLens.Message FieldDescriptorProto where+  messageName _+    = Data.Text.pack "google.protobuf.FieldDescriptorProto"+  fieldsByTag+    = let+        name__field_descriptor+          = Data.ProtoLens.FieldDescriptor+              "name"+              (Data.ProtoLens.ScalarField Data.ProtoLens.StringField ::+                 Data.ProtoLens.FieldTypeDescriptor Data.Text.Text)+              (Data.ProtoLens.OptionalField+                 (Data.ProtoLens.Field.field @"maybe'name")) ::+              Data.ProtoLens.FieldDescriptor FieldDescriptorProto+        number__field_descriptor+          = Data.ProtoLens.FieldDescriptor+              "number"+              (Data.ProtoLens.ScalarField Data.ProtoLens.Int32Field ::+                 Data.ProtoLens.FieldTypeDescriptor Data.Int.Int32)+              (Data.ProtoLens.OptionalField+                 (Data.ProtoLens.Field.field @"maybe'number")) ::+              Data.ProtoLens.FieldDescriptor FieldDescriptorProto+        label__field_descriptor+          = Data.ProtoLens.FieldDescriptor+              "label"+              (Data.ProtoLens.ScalarField Data.ProtoLens.EnumField ::+                 Data.ProtoLens.FieldTypeDescriptor FieldDescriptorProto'Label)+              (Data.ProtoLens.OptionalField+                 (Data.ProtoLens.Field.field @"maybe'label")) ::+              Data.ProtoLens.FieldDescriptor FieldDescriptorProto+        type'__field_descriptor+          = Data.ProtoLens.FieldDescriptor+              "type"+              (Data.ProtoLens.ScalarField Data.ProtoLens.EnumField ::+                 Data.ProtoLens.FieldTypeDescriptor FieldDescriptorProto'Type)+              (Data.ProtoLens.OptionalField+                 (Data.ProtoLens.Field.field @"maybe'type'")) ::+              Data.ProtoLens.FieldDescriptor FieldDescriptorProto+        typeName__field_descriptor+          = Data.ProtoLens.FieldDescriptor+              "type_name"+              (Data.ProtoLens.ScalarField Data.ProtoLens.StringField ::+                 Data.ProtoLens.FieldTypeDescriptor Data.Text.Text)+              (Data.ProtoLens.OptionalField+                 (Data.ProtoLens.Field.field @"maybe'typeName")) ::+              Data.ProtoLens.FieldDescriptor FieldDescriptorProto+        extendee__field_descriptor+          = Data.ProtoLens.FieldDescriptor+              "extendee"+              (Data.ProtoLens.ScalarField Data.ProtoLens.StringField ::+                 Data.ProtoLens.FieldTypeDescriptor Data.Text.Text)+              (Data.ProtoLens.OptionalField+                 (Data.ProtoLens.Field.field @"maybe'extendee")) ::+              Data.ProtoLens.FieldDescriptor FieldDescriptorProto+        defaultValue__field_descriptor+          = Data.ProtoLens.FieldDescriptor+              "default_value"+              (Data.ProtoLens.ScalarField Data.ProtoLens.StringField ::+                 Data.ProtoLens.FieldTypeDescriptor Data.Text.Text)+              (Data.ProtoLens.OptionalField+                 (Data.ProtoLens.Field.field @"maybe'defaultValue")) ::+              Data.ProtoLens.FieldDescriptor FieldDescriptorProto+        oneofIndex__field_descriptor+          = Data.ProtoLens.FieldDescriptor+              "oneof_index"+              (Data.ProtoLens.ScalarField Data.ProtoLens.Int32Field ::+                 Data.ProtoLens.FieldTypeDescriptor Data.Int.Int32)+              (Data.ProtoLens.OptionalField+                 (Data.ProtoLens.Field.field @"maybe'oneofIndex")) ::+              Data.ProtoLens.FieldDescriptor FieldDescriptorProto+        jsonName__field_descriptor+          = Data.ProtoLens.FieldDescriptor+              "json_name"+              (Data.ProtoLens.ScalarField Data.ProtoLens.StringField ::+                 Data.ProtoLens.FieldTypeDescriptor Data.Text.Text)+              (Data.ProtoLens.OptionalField+                 (Data.ProtoLens.Field.field @"maybe'jsonName")) ::+              Data.ProtoLens.FieldDescriptor FieldDescriptorProto+        options__field_descriptor+          = Data.ProtoLens.FieldDescriptor+              "options"+              (Data.ProtoLens.MessageField Data.ProtoLens.MessageType ::+                 Data.ProtoLens.FieldTypeDescriptor FieldOptions)+              (Data.ProtoLens.OptionalField+                 (Data.ProtoLens.Field.field @"maybe'options")) ::+              Data.ProtoLens.FieldDescriptor FieldDescriptorProto+      in+        Data.Map.fromList+          [(Data.ProtoLens.Tag 1, name__field_descriptor),+           (Data.ProtoLens.Tag 3, number__field_descriptor),+           (Data.ProtoLens.Tag 4, label__field_descriptor),+           (Data.ProtoLens.Tag 5, type'__field_descriptor),+           (Data.ProtoLens.Tag 6, typeName__field_descriptor),+           (Data.ProtoLens.Tag 2, extendee__field_descriptor),+           (Data.ProtoLens.Tag 7, defaultValue__field_descriptor),+           (Data.ProtoLens.Tag 9, oneofIndex__field_descriptor),+           (Data.ProtoLens.Tag 10, jsonName__field_descriptor),+           (Data.ProtoLens.Tag 8, options__field_descriptor)]+  unknownFields+    = Lens.Family2.Unchecked.lens+        _FieldDescriptorProto'_unknownFields+        (\ x__ y__ -> x__ {_FieldDescriptorProto'_unknownFields = y__})+  defMessage+    = FieldDescriptorProto'_constructor+        {_FieldDescriptorProto'name = Prelude.Nothing,+         _FieldDescriptorProto'number = Prelude.Nothing,+         _FieldDescriptorProto'label = Prelude.Nothing,+         _FieldDescriptorProto'type' = Prelude.Nothing,+         _FieldDescriptorProto'typeName = Prelude.Nothing,+         _FieldDescriptorProto'extendee = Prelude.Nothing,+         _FieldDescriptorProto'defaultValue = Prelude.Nothing,+         _FieldDescriptorProto'oneofIndex = Prelude.Nothing,+         _FieldDescriptorProto'jsonName = Prelude.Nothing,+         _FieldDescriptorProto'options = Prelude.Nothing,+         _FieldDescriptorProto'_unknownFields = []}+  parseMessage+    = let+        loop ::+          FieldDescriptorProto+          -> Data.ProtoLens.Encoding.Bytes.Parser FieldDescriptorProto+        loop x+          = do end <- Data.ProtoLens.Encoding.Bytes.atEnd+               if end then+                   do (let missing = []+                       in+                         if Prelude.null missing then+                             Prelude.return ()+                         else+                             Prelude.fail+                               ((Prelude.++)+                                  "Missing required fields: "+                                  (Prelude.show (missing :: [Prelude.String]))))+                      Prelude.return+                        (Lens.Family2.over+                           Data.ProtoLens.unknownFields (\ !t -> Prelude.reverse t) x)+               else+                   do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt+                      case tag of+                        10+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)+                                       (do value <- do len <- Data.ProtoLens.Encoding.Bytes.getVarInt+                                                       Data.ProtoLens.Encoding.Bytes.getBytes+                                                         (Prelude.fromIntegral len)+                                           Data.ProtoLens.Encoding.Bytes.runEither+                                             (case Data.Text.Encoding.decodeUtf8' value of+                                                (Prelude.Left err)+                                                  -> Prelude.Left (Prelude.show err)+                                                (Prelude.Right r) -> Prelude.Right r))+                                       "name"+                                loop (Lens.Family2.set (Data.ProtoLens.Field.field @"name") y x)+                        24+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)+                                       (Prelude.fmap+                                          Prelude.fromIntegral+                                          Data.ProtoLens.Encoding.Bytes.getVarInt)+                                       "number"+                                loop (Lens.Family2.set (Data.ProtoLens.Field.field @"number") y x)+                        32+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)+                                       (Prelude.fmap+                                          Prelude.toEnum+                                          (Prelude.fmap+                                             Prelude.fromIntegral+                                             Data.ProtoLens.Encoding.Bytes.getVarInt))+                                       "label"+                                loop (Lens.Family2.set (Data.ProtoLens.Field.field @"label") y x)+                        40+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)+                                       (Prelude.fmap+                                          Prelude.toEnum+                                          (Prelude.fmap+                                             Prelude.fromIntegral+                                             Data.ProtoLens.Encoding.Bytes.getVarInt))+                                       "type"+                                loop (Lens.Family2.set (Data.ProtoLens.Field.field @"type'") y x)+                        50+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)+                                       (do value <- do len <- Data.ProtoLens.Encoding.Bytes.getVarInt+                                                       Data.ProtoLens.Encoding.Bytes.getBytes+                                                         (Prelude.fromIntegral len)+                                           Data.ProtoLens.Encoding.Bytes.runEither+                                             (case Data.Text.Encoding.decodeUtf8' value of+                                                (Prelude.Left err)+                                                  -> Prelude.Left (Prelude.show err)+                                                (Prelude.Right r) -> Prelude.Right r))+                                       "type_name"+                                loop+                                  (Lens.Family2.set (Data.ProtoLens.Field.field @"typeName") y x)+                        18+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)+                                       (do value <- do len <- Data.ProtoLens.Encoding.Bytes.getVarInt+                                                       Data.ProtoLens.Encoding.Bytes.getBytes+                                                         (Prelude.fromIntegral len)+                                           Data.ProtoLens.Encoding.Bytes.runEither+                                             (case Data.Text.Encoding.decodeUtf8' value of+                                                (Prelude.Left err)+                                                  -> Prelude.Left (Prelude.show err)+                                                (Prelude.Right r) -> Prelude.Right r))+                                       "extendee"+                                loop+                                  (Lens.Family2.set (Data.ProtoLens.Field.field @"extendee") y x)+                        58+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)+                                       (do value <- do len <- Data.ProtoLens.Encoding.Bytes.getVarInt+                                                       Data.ProtoLens.Encoding.Bytes.getBytes+                                                         (Prelude.fromIntegral len)+                                           Data.ProtoLens.Encoding.Bytes.runEither+                                             (case Data.Text.Encoding.decodeUtf8' value of+                                                (Prelude.Left err)+                                                  -> Prelude.Left (Prelude.show err)+                                                (Prelude.Right r) -> Prelude.Right r))+                                       "default_value"+                                loop+                                  (Lens.Family2.set+                                     (Data.ProtoLens.Field.field @"defaultValue") y x)+                        72+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)+                                       (Prelude.fmap+                                          Prelude.fromIntegral+                                          Data.ProtoLens.Encoding.Bytes.getVarInt)+                                       "oneof_index"+                                loop+                                  (Lens.Family2.set (Data.ProtoLens.Field.field @"oneofIndex") y x)+                        82+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)+                                       (do value <- do len <- Data.ProtoLens.Encoding.Bytes.getVarInt+                                                       Data.ProtoLens.Encoding.Bytes.getBytes+                                                         (Prelude.fromIntegral len)+                                           Data.ProtoLens.Encoding.Bytes.runEither+                                             (case Data.Text.Encoding.decodeUtf8' value of+                                                (Prelude.Left err)+                                                  -> Prelude.Left (Prelude.show err)+                                                (Prelude.Right r) -> Prelude.Right r))+                                       "json_name"+                                loop+                                  (Lens.Family2.set (Data.ProtoLens.Field.field @"jsonName") y x)+                        66+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)+                                       (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt+                                           Data.ProtoLens.Encoding.Bytes.isolate+                                             (Prelude.fromIntegral len) Data.ProtoLens.parseMessage)+                                       "options"+                                loop (Lens.Family2.set (Data.ProtoLens.Field.field @"options") y x)+                        wire+                          -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire+                                        wire+                                loop+                                  (Lens.Family2.over+                                     Data.ProtoLens.unknownFields (\ !t -> (:) y t) x)+      in+        (Data.ProtoLens.Encoding.Bytes.<?>)+          (do loop Data.ProtoLens.defMessage) "FieldDescriptorProto"+  buildMessage+    = \ _x+        -> (Data.Monoid.<>)+             (case+                  Lens.Family2.view (Data.ProtoLens.Field.field @"maybe'name") _x+              of+                Prelude.Nothing -> Data.Monoid.mempty+                (Prelude.Just _v)+                  -> (Data.Monoid.<>)+                       (Data.ProtoLens.Encoding.Bytes.putVarInt 10)+                       ((Prelude..)+                          (\ bs+                             -> (Data.Monoid.<>)+                                  (Data.ProtoLens.Encoding.Bytes.putVarInt+                                     (Prelude.fromIntegral (Data.ByteString.length bs)))+                                  (Data.ProtoLens.Encoding.Bytes.putBytes bs))+                          Data.Text.Encoding.encodeUtf8+                          _v))+             ((Data.Monoid.<>)+                (case+                     Lens.Family2.view (Data.ProtoLens.Field.field @"maybe'number") _x+                 of+                   Prelude.Nothing -> Data.Monoid.mempty+                   (Prelude.Just _v)+                     -> (Data.Monoid.<>)+                          (Data.ProtoLens.Encoding.Bytes.putVarInt 24)+                          ((Prelude..)+                             Data.ProtoLens.Encoding.Bytes.putVarInt Prelude.fromIntegral _v))+                ((Data.Monoid.<>)+                   (case+                        Lens.Family2.view (Data.ProtoLens.Field.field @"maybe'label") _x+                    of+                      Prelude.Nothing -> Data.Monoid.mempty+                      (Prelude.Just _v)+                        -> (Data.Monoid.<>)+                             (Data.ProtoLens.Encoding.Bytes.putVarInt 32)+                             ((Prelude..)+                                ((Prelude..)+                                   Data.ProtoLens.Encoding.Bytes.putVarInt Prelude.fromIntegral)+                                Prelude.fromEnum+                                _v))+                   ((Data.Monoid.<>)+                      (case+                           Lens.Family2.view (Data.ProtoLens.Field.field @"maybe'type'") _x+                       of+                         Prelude.Nothing -> Data.Monoid.mempty+                         (Prelude.Just _v)+                           -> (Data.Monoid.<>)+                                (Data.ProtoLens.Encoding.Bytes.putVarInt 40)+                                ((Prelude..)+                                   ((Prelude..)+                                      Data.ProtoLens.Encoding.Bytes.putVarInt Prelude.fromIntegral)+                                   Prelude.fromEnum+                                   _v))+                      ((Data.Monoid.<>)+                         (case+                              Lens.Family2.view (Data.ProtoLens.Field.field @"maybe'typeName") _x+                          of+                            Prelude.Nothing -> Data.Monoid.mempty+                            (Prelude.Just _v)+                              -> (Data.Monoid.<>)+                                   (Data.ProtoLens.Encoding.Bytes.putVarInt 50)+                                   ((Prelude..)+                                      (\ bs+                                         -> (Data.Monoid.<>)+                                              (Data.ProtoLens.Encoding.Bytes.putVarInt+                                                 (Prelude.fromIntegral (Data.ByteString.length bs)))+                                              (Data.ProtoLens.Encoding.Bytes.putBytes bs))+                                      Data.Text.Encoding.encodeUtf8+                                      _v))+                         ((Data.Monoid.<>)+                            (case+                                 Lens.Family2.view (Data.ProtoLens.Field.field @"maybe'extendee") _x+                             of+                               Prelude.Nothing -> Data.Monoid.mempty+                               (Prelude.Just _v)+                                 -> (Data.Monoid.<>)+                                      (Data.ProtoLens.Encoding.Bytes.putVarInt 18)+                                      ((Prelude..)+                                         (\ bs+                                            -> (Data.Monoid.<>)+                                                 (Data.ProtoLens.Encoding.Bytes.putVarInt+                                                    (Prelude.fromIntegral+                                                       (Data.ByteString.length bs)))+                                                 (Data.ProtoLens.Encoding.Bytes.putBytes bs))+                                         Data.Text.Encoding.encodeUtf8+                                         _v))+                            ((Data.Monoid.<>)+                               (case+                                    Lens.Family2.view+                                      (Data.ProtoLens.Field.field @"maybe'defaultValue") _x+                                of+                                  Prelude.Nothing -> Data.Monoid.mempty+                                  (Prelude.Just _v)+                                    -> (Data.Monoid.<>)+                                         (Data.ProtoLens.Encoding.Bytes.putVarInt 58)+                                         ((Prelude..)+                                            (\ bs+                                               -> (Data.Monoid.<>)+                                                    (Data.ProtoLens.Encoding.Bytes.putVarInt+                                                       (Prelude.fromIntegral+                                                          (Data.ByteString.length bs)))+                                                    (Data.ProtoLens.Encoding.Bytes.putBytes bs))+                                            Data.Text.Encoding.encodeUtf8+                                            _v))+                               ((Data.Monoid.<>)+                                  (case+                                       Lens.Family2.view+                                         (Data.ProtoLens.Field.field @"maybe'oneofIndex") _x+                                   of+                                     Prelude.Nothing -> Data.Monoid.mempty+                                     (Prelude.Just _v)+                                       -> (Data.Monoid.<>)+                                            (Data.ProtoLens.Encoding.Bytes.putVarInt 72)+                                            ((Prelude..)+                                               Data.ProtoLens.Encoding.Bytes.putVarInt+                                               Prelude.fromIntegral+                                               _v))+                                  ((Data.Monoid.<>)+                                     (case+                                          Lens.Family2.view+                                            (Data.ProtoLens.Field.field @"maybe'jsonName") _x+                                      of+                                        Prelude.Nothing -> Data.Monoid.mempty+                                        (Prelude.Just _v)+                                          -> (Data.Monoid.<>)+                                               (Data.ProtoLens.Encoding.Bytes.putVarInt 82)+                                               ((Prelude..)+                                                  (\ bs+                                                     -> (Data.Monoid.<>)+                                                          (Data.ProtoLens.Encoding.Bytes.putVarInt+                                                             (Prelude.fromIntegral+                                                                (Data.ByteString.length bs)))+                                                          (Data.ProtoLens.Encoding.Bytes.putBytes+                                                             bs))+                                                  Data.Text.Encoding.encodeUtf8+                                                  _v))+                                     ((Data.Monoid.<>)+                                        (case+                                             Lens.Family2.view+                                               (Data.ProtoLens.Field.field @"maybe'options") _x+                                         of+                                           Prelude.Nothing -> Data.Monoid.mempty+                                           (Prelude.Just _v)+                                             -> (Data.Monoid.<>)+                                                  (Data.ProtoLens.Encoding.Bytes.putVarInt 66)+                                                  ((Prelude..)+                                                     (\ bs+                                                        -> (Data.Monoid.<>)+                                                             (Data.ProtoLens.Encoding.Bytes.putVarInt+                                                                (Prelude.fromIntegral+                                                                   (Data.ByteString.length bs)))+                                                             (Data.ProtoLens.Encoding.Bytes.putBytes+                                                                bs))+                                                     Data.ProtoLens.encodeMessage+                                                     _v))+                                        (Data.ProtoLens.Encoding.Wire.buildFieldSet+                                           (Lens.Family2.view+                                              Data.ProtoLens.unknownFields _x)))))))))))+instance Control.DeepSeq.NFData FieldDescriptorProto where+  rnf+    = \ x__+        -> Control.DeepSeq.deepseq+             (_FieldDescriptorProto'_unknownFields x__)+             (Control.DeepSeq.deepseq+                (_FieldDescriptorProto'name x__)+                (Control.DeepSeq.deepseq+                   (_FieldDescriptorProto'number x__)+                   (Control.DeepSeq.deepseq+                      (_FieldDescriptorProto'label x__)+                      (Control.DeepSeq.deepseq+                         (_FieldDescriptorProto'type' x__)+                         (Control.DeepSeq.deepseq+                            (_FieldDescriptorProto'typeName x__)+                            (Control.DeepSeq.deepseq+                               (_FieldDescriptorProto'extendee x__)+                               (Control.DeepSeq.deepseq+                                  (_FieldDescriptorProto'defaultValue x__)+                                  (Control.DeepSeq.deepseq+                                     (_FieldDescriptorProto'oneofIndex x__)+                                     (Control.DeepSeq.deepseq+                                        (_FieldDescriptorProto'jsonName x__)+                                        (Control.DeepSeq.deepseq+                                           (_FieldDescriptorProto'options x__) ()))))))))))+data FieldDescriptorProto'Label+  = FieldDescriptorProto'LABEL_OPTIONAL |+    FieldDescriptorProto'LABEL_REQUIRED |+    FieldDescriptorProto'LABEL_REPEATED+  deriving (Prelude.Show, Prelude.Eq, Prelude.Ord)+instance Data.ProtoLens.MessageEnum FieldDescriptorProto'Label where+  maybeToEnum 1 = Prelude.Just FieldDescriptorProto'LABEL_OPTIONAL+  maybeToEnum 2 = Prelude.Just FieldDescriptorProto'LABEL_REQUIRED+  maybeToEnum 3 = Prelude.Just FieldDescriptorProto'LABEL_REPEATED+  maybeToEnum _ = Prelude.Nothing+  showEnum FieldDescriptorProto'LABEL_OPTIONAL = "LABEL_OPTIONAL"+  showEnum FieldDescriptorProto'LABEL_REQUIRED = "LABEL_REQUIRED"+  showEnum FieldDescriptorProto'LABEL_REPEATED = "LABEL_REPEATED"+  readEnum k+    | (Prelude.==) k "LABEL_OPTIONAL"+    = Prelude.Just FieldDescriptorProto'LABEL_OPTIONAL+    | (Prelude.==) k "LABEL_REQUIRED"+    = Prelude.Just FieldDescriptorProto'LABEL_REQUIRED+    | (Prelude.==) k "LABEL_REPEATED"+    = Prelude.Just FieldDescriptorProto'LABEL_REPEATED+    | Prelude.otherwise+    = (Prelude.>>=) (Text.Read.readMaybe k) Data.ProtoLens.maybeToEnum+instance Prelude.Bounded FieldDescriptorProto'Label where+  minBound = FieldDescriptorProto'LABEL_OPTIONAL+  maxBound = FieldDescriptorProto'LABEL_REPEATED+instance Prelude.Enum FieldDescriptorProto'Label where+  toEnum k__+    = Prelude.maybe+        (Prelude.error+           ((Prelude.++)+              "toEnum: unknown value for enum Label: " (Prelude.show k__)))+        Prelude.id+        (Data.ProtoLens.maybeToEnum k__)+  fromEnum FieldDescriptorProto'LABEL_OPTIONAL = 1+  fromEnum FieldDescriptorProto'LABEL_REQUIRED = 2+  fromEnum FieldDescriptorProto'LABEL_REPEATED = 3+  succ FieldDescriptorProto'LABEL_REPEATED+    = Prelude.error+        "FieldDescriptorProto'Label.succ: bad argument FieldDescriptorProto'LABEL_REPEATED. This value would be out of bounds."+  succ FieldDescriptorProto'LABEL_OPTIONAL+    = FieldDescriptorProto'LABEL_REQUIRED+  succ FieldDescriptorProto'LABEL_REQUIRED+    = FieldDescriptorProto'LABEL_REPEATED+  pred FieldDescriptorProto'LABEL_OPTIONAL+    = Prelude.error+        "FieldDescriptorProto'Label.pred: bad argument FieldDescriptorProto'LABEL_OPTIONAL. This value would be out of bounds."+  pred FieldDescriptorProto'LABEL_REQUIRED+    = FieldDescriptorProto'LABEL_OPTIONAL+  pred FieldDescriptorProto'LABEL_REPEATED+    = FieldDescriptorProto'LABEL_REQUIRED+  enumFrom = Data.ProtoLens.Message.Enum.messageEnumFrom+  enumFromTo = Data.ProtoLens.Message.Enum.messageEnumFromTo+  enumFromThen = Data.ProtoLens.Message.Enum.messageEnumFromThen+  enumFromThenTo = Data.ProtoLens.Message.Enum.messageEnumFromThenTo+instance Data.ProtoLens.FieldDefault FieldDescriptorProto'Label where+  fieldDefault = FieldDescriptorProto'LABEL_OPTIONAL+instance Control.DeepSeq.NFData FieldDescriptorProto'Label where+  rnf x__ = Prelude.seq x__ ()+data FieldDescriptorProto'Type+  = FieldDescriptorProto'TYPE_DOUBLE |+    FieldDescriptorProto'TYPE_FLOAT |+    FieldDescriptorProto'TYPE_INT64 |+    FieldDescriptorProto'TYPE_UINT64 |+    FieldDescriptorProto'TYPE_INT32 |+    FieldDescriptorProto'TYPE_FIXED64 |+    FieldDescriptorProto'TYPE_FIXED32 |+    FieldDescriptorProto'TYPE_BOOL |+    FieldDescriptorProto'TYPE_STRING |+    FieldDescriptorProto'TYPE_GROUP |+    FieldDescriptorProto'TYPE_MESSAGE |+    FieldDescriptorProto'TYPE_BYTES |+    FieldDescriptorProto'TYPE_UINT32 |+    FieldDescriptorProto'TYPE_ENUM |+    FieldDescriptorProto'TYPE_SFIXED32 |+    FieldDescriptorProto'TYPE_SFIXED64 |+    FieldDescriptorProto'TYPE_SINT32 |+    FieldDescriptorProto'TYPE_SINT64+  deriving (Prelude.Show, Prelude.Eq, Prelude.Ord)+instance Data.ProtoLens.MessageEnum FieldDescriptorProto'Type where+  maybeToEnum 1 = Prelude.Just FieldDescriptorProto'TYPE_DOUBLE+  maybeToEnum 2 = Prelude.Just FieldDescriptorProto'TYPE_FLOAT+  maybeToEnum 3 = Prelude.Just FieldDescriptorProto'TYPE_INT64+  maybeToEnum 4 = Prelude.Just FieldDescriptorProto'TYPE_UINT64+  maybeToEnum 5 = Prelude.Just FieldDescriptorProto'TYPE_INT32+  maybeToEnum 6 = Prelude.Just FieldDescriptorProto'TYPE_FIXED64+  maybeToEnum 7 = Prelude.Just FieldDescriptorProto'TYPE_FIXED32+  maybeToEnum 8 = Prelude.Just FieldDescriptorProto'TYPE_BOOL+  maybeToEnum 9 = Prelude.Just FieldDescriptorProto'TYPE_STRING+  maybeToEnum 10 = Prelude.Just FieldDescriptorProto'TYPE_GROUP+  maybeToEnum 11 = Prelude.Just FieldDescriptorProto'TYPE_MESSAGE+  maybeToEnum 12 = Prelude.Just FieldDescriptorProto'TYPE_BYTES+  maybeToEnum 13 = Prelude.Just FieldDescriptorProto'TYPE_UINT32+  maybeToEnum 14 = Prelude.Just FieldDescriptorProto'TYPE_ENUM+  maybeToEnum 15 = Prelude.Just FieldDescriptorProto'TYPE_SFIXED32+  maybeToEnum 16 = Prelude.Just FieldDescriptorProto'TYPE_SFIXED64+  maybeToEnum 17 = Prelude.Just FieldDescriptorProto'TYPE_SINT32+  maybeToEnum 18 = Prelude.Just FieldDescriptorProto'TYPE_SINT64+  maybeToEnum _ = Prelude.Nothing+  showEnum FieldDescriptorProto'TYPE_DOUBLE = "TYPE_DOUBLE"+  showEnum FieldDescriptorProto'TYPE_FLOAT = "TYPE_FLOAT"+  showEnum FieldDescriptorProto'TYPE_INT64 = "TYPE_INT64"+  showEnum FieldDescriptorProto'TYPE_UINT64 = "TYPE_UINT64"+  showEnum FieldDescriptorProto'TYPE_INT32 = "TYPE_INT32"+  showEnum FieldDescriptorProto'TYPE_FIXED64 = "TYPE_FIXED64"+  showEnum FieldDescriptorProto'TYPE_FIXED32 = "TYPE_FIXED32"+  showEnum FieldDescriptorProto'TYPE_BOOL = "TYPE_BOOL"+  showEnum FieldDescriptorProto'TYPE_STRING = "TYPE_STRING"+  showEnum FieldDescriptorProto'TYPE_GROUP = "TYPE_GROUP"+  showEnum FieldDescriptorProto'TYPE_MESSAGE = "TYPE_MESSAGE"+  showEnum FieldDescriptorProto'TYPE_BYTES = "TYPE_BYTES"+  showEnum FieldDescriptorProto'TYPE_UINT32 = "TYPE_UINT32"+  showEnum FieldDescriptorProto'TYPE_ENUM = "TYPE_ENUM"+  showEnum FieldDescriptorProto'TYPE_SFIXED32 = "TYPE_SFIXED32"+  showEnum FieldDescriptorProto'TYPE_SFIXED64 = "TYPE_SFIXED64"+  showEnum FieldDescriptorProto'TYPE_SINT32 = "TYPE_SINT32"+  showEnum FieldDescriptorProto'TYPE_SINT64 = "TYPE_SINT64"+  readEnum k+    | (Prelude.==) k "TYPE_DOUBLE"+    = Prelude.Just FieldDescriptorProto'TYPE_DOUBLE+    | (Prelude.==) k "TYPE_FLOAT"+    = Prelude.Just FieldDescriptorProto'TYPE_FLOAT+    | (Prelude.==) k "TYPE_INT64"+    = Prelude.Just FieldDescriptorProto'TYPE_INT64+    | (Prelude.==) k "TYPE_UINT64"+    = Prelude.Just FieldDescriptorProto'TYPE_UINT64+    | (Prelude.==) k "TYPE_INT32"+    = Prelude.Just FieldDescriptorProto'TYPE_INT32+    | (Prelude.==) k "TYPE_FIXED64"+    = Prelude.Just FieldDescriptorProto'TYPE_FIXED64+    | (Prelude.==) k "TYPE_FIXED32"+    = Prelude.Just FieldDescriptorProto'TYPE_FIXED32+    | (Prelude.==) k "TYPE_BOOL"+    = Prelude.Just FieldDescriptorProto'TYPE_BOOL+    | (Prelude.==) k "TYPE_STRING"+    = Prelude.Just FieldDescriptorProto'TYPE_STRING+    | (Prelude.==) k "TYPE_GROUP"+    = Prelude.Just FieldDescriptorProto'TYPE_GROUP+    | (Prelude.==) k "TYPE_MESSAGE"+    = Prelude.Just FieldDescriptorProto'TYPE_MESSAGE+    | (Prelude.==) k "TYPE_BYTES"+    = Prelude.Just FieldDescriptorProto'TYPE_BYTES+    | (Prelude.==) k "TYPE_UINT32"+    = Prelude.Just FieldDescriptorProto'TYPE_UINT32+    | (Prelude.==) k "TYPE_ENUM"+    = Prelude.Just FieldDescriptorProto'TYPE_ENUM+    | (Prelude.==) k "TYPE_SFIXED32"+    = Prelude.Just FieldDescriptorProto'TYPE_SFIXED32+    | (Prelude.==) k "TYPE_SFIXED64"+    = Prelude.Just FieldDescriptorProto'TYPE_SFIXED64+    | (Prelude.==) k "TYPE_SINT32"+    = Prelude.Just FieldDescriptorProto'TYPE_SINT32+    | (Prelude.==) k "TYPE_SINT64"+    = Prelude.Just FieldDescriptorProto'TYPE_SINT64+    | Prelude.otherwise+    = (Prelude.>>=) (Text.Read.readMaybe k) Data.ProtoLens.maybeToEnum+instance Prelude.Bounded FieldDescriptorProto'Type where+  minBound = FieldDescriptorProto'TYPE_DOUBLE+  maxBound = FieldDescriptorProto'TYPE_SINT64+instance Prelude.Enum FieldDescriptorProto'Type where+  toEnum k__+    = Prelude.maybe+        (Prelude.error+           ((Prelude.++)+              "toEnum: unknown value for enum Type: " (Prelude.show k__)))+        Prelude.id+        (Data.ProtoLens.maybeToEnum k__)+  fromEnum FieldDescriptorProto'TYPE_DOUBLE = 1+  fromEnum FieldDescriptorProto'TYPE_FLOAT = 2+  fromEnum FieldDescriptorProto'TYPE_INT64 = 3+  fromEnum FieldDescriptorProto'TYPE_UINT64 = 4+  fromEnum FieldDescriptorProto'TYPE_INT32 = 5+  fromEnum FieldDescriptorProto'TYPE_FIXED64 = 6+  fromEnum FieldDescriptorProto'TYPE_FIXED32 = 7+  fromEnum FieldDescriptorProto'TYPE_BOOL = 8+  fromEnum FieldDescriptorProto'TYPE_STRING = 9+  fromEnum FieldDescriptorProto'TYPE_GROUP = 10+  fromEnum FieldDescriptorProto'TYPE_MESSAGE = 11+  fromEnum FieldDescriptorProto'TYPE_BYTES = 12+  fromEnum FieldDescriptorProto'TYPE_UINT32 = 13+  fromEnum FieldDescriptorProto'TYPE_ENUM = 14+  fromEnum FieldDescriptorProto'TYPE_SFIXED32 = 15+  fromEnum FieldDescriptorProto'TYPE_SFIXED64 = 16+  fromEnum FieldDescriptorProto'TYPE_SINT32 = 17+  fromEnum FieldDescriptorProto'TYPE_SINT64 = 18+  succ FieldDescriptorProto'TYPE_SINT64+    = Prelude.error+        "FieldDescriptorProto'Type.succ: bad argument FieldDescriptorProto'TYPE_SINT64. This value would be out of bounds."+  succ FieldDescriptorProto'TYPE_DOUBLE+    = FieldDescriptorProto'TYPE_FLOAT+  succ FieldDescriptorProto'TYPE_FLOAT+    = FieldDescriptorProto'TYPE_INT64+  succ FieldDescriptorProto'TYPE_INT64+    = FieldDescriptorProto'TYPE_UINT64+  succ FieldDescriptorProto'TYPE_UINT64+    = FieldDescriptorProto'TYPE_INT32+  succ FieldDescriptorProto'TYPE_INT32+    = FieldDescriptorProto'TYPE_FIXED64+  succ FieldDescriptorProto'TYPE_FIXED64+    = FieldDescriptorProto'TYPE_FIXED32+  succ FieldDescriptorProto'TYPE_FIXED32+    = FieldDescriptorProto'TYPE_BOOL+  succ FieldDescriptorProto'TYPE_BOOL+    = FieldDescriptorProto'TYPE_STRING+  succ FieldDescriptorProto'TYPE_STRING+    = FieldDescriptorProto'TYPE_GROUP+  succ FieldDescriptorProto'TYPE_GROUP+    = FieldDescriptorProto'TYPE_MESSAGE+  succ FieldDescriptorProto'TYPE_MESSAGE+    = FieldDescriptorProto'TYPE_BYTES+  succ FieldDescriptorProto'TYPE_BYTES+    = FieldDescriptorProto'TYPE_UINT32+  succ FieldDescriptorProto'TYPE_UINT32+    = FieldDescriptorProto'TYPE_ENUM+  succ FieldDescriptorProto'TYPE_ENUM+    = FieldDescriptorProto'TYPE_SFIXED32+  succ FieldDescriptorProto'TYPE_SFIXED32+    = FieldDescriptorProto'TYPE_SFIXED64+  succ FieldDescriptorProto'TYPE_SFIXED64+    = FieldDescriptorProto'TYPE_SINT32+  succ FieldDescriptorProto'TYPE_SINT32+    = FieldDescriptorProto'TYPE_SINT64+  pred FieldDescriptorProto'TYPE_DOUBLE+    = Prelude.error+        "FieldDescriptorProto'Type.pred: bad argument FieldDescriptorProto'TYPE_DOUBLE. This value would be out of bounds."+  pred FieldDescriptorProto'TYPE_FLOAT+    = FieldDescriptorProto'TYPE_DOUBLE+  pred FieldDescriptorProto'TYPE_INT64+    = FieldDescriptorProto'TYPE_FLOAT+  pred FieldDescriptorProto'TYPE_UINT64+    = FieldDescriptorProto'TYPE_INT64+  pred FieldDescriptorProto'TYPE_INT32+    = FieldDescriptorProto'TYPE_UINT64+  pred FieldDescriptorProto'TYPE_FIXED64+    = FieldDescriptorProto'TYPE_INT32+  pred FieldDescriptorProto'TYPE_FIXED32+    = FieldDescriptorProto'TYPE_FIXED64+  pred FieldDescriptorProto'TYPE_BOOL+    = FieldDescriptorProto'TYPE_FIXED32+  pred FieldDescriptorProto'TYPE_STRING+    = FieldDescriptorProto'TYPE_BOOL+  pred FieldDescriptorProto'TYPE_GROUP+    = FieldDescriptorProto'TYPE_STRING+  pred FieldDescriptorProto'TYPE_MESSAGE+    = FieldDescriptorProto'TYPE_GROUP+  pred FieldDescriptorProto'TYPE_BYTES+    = FieldDescriptorProto'TYPE_MESSAGE+  pred FieldDescriptorProto'TYPE_UINT32+    = FieldDescriptorProto'TYPE_BYTES+  pred FieldDescriptorProto'TYPE_ENUM+    = FieldDescriptorProto'TYPE_UINT32+  pred FieldDescriptorProto'TYPE_SFIXED32+    = FieldDescriptorProto'TYPE_ENUM+  pred FieldDescriptorProto'TYPE_SFIXED64+    = FieldDescriptorProto'TYPE_SFIXED32+  pred FieldDescriptorProto'TYPE_SINT32+    = FieldDescriptorProto'TYPE_SFIXED64+  pred FieldDescriptorProto'TYPE_SINT64+    = FieldDescriptorProto'TYPE_SINT32+  enumFrom = Data.ProtoLens.Message.Enum.messageEnumFrom+  enumFromTo = Data.ProtoLens.Message.Enum.messageEnumFromTo+  enumFromThen = Data.ProtoLens.Message.Enum.messageEnumFromThen+  enumFromThenTo = Data.ProtoLens.Message.Enum.messageEnumFromThenTo+instance Data.ProtoLens.FieldDefault FieldDescriptorProto'Type where+  fieldDefault = FieldDescriptorProto'TYPE_DOUBLE+instance Control.DeepSeq.NFData FieldDescriptorProto'Type where+  rnf x__ = Prelude.seq x__ ()+{- | Fields :+     +         * 'Proto.Google.Protobuf.Descriptor_Fields.ctype' @:: Lens' FieldOptions FieldOptions'CType@+         * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'ctype' @:: Lens' FieldOptions (Prelude.Maybe FieldOptions'CType)@+         * 'Proto.Google.Protobuf.Descriptor_Fields.packed' @:: Lens' FieldOptions Prelude.Bool@+         * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'packed' @:: Lens' FieldOptions (Prelude.Maybe Prelude.Bool)@+         * 'Proto.Google.Protobuf.Descriptor_Fields.jstype' @:: Lens' FieldOptions FieldOptions'JSType@+         * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'jstype' @:: Lens' FieldOptions (Prelude.Maybe FieldOptions'JSType)@+         * 'Proto.Google.Protobuf.Descriptor_Fields.lazy' @:: Lens' FieldOptions Prelude.Bool@+         * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'lazy' @:: Lens' FieldOptions (Prelude.Maybe Prelude.Bool)@+         * 'Proto.Google.Protobuf.Descriptor_Fields.deprecated' @:: Lens' FieldOptions Prelude.Bool@+         * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'deprecated' @:: Lens' FieldOptions (Prelude.Maybe Prelude.Bool)@+         * 'Proto.Google.Protobuf.Descriptor_Fields.weak' @:: Lens' FieldOptions Prelude.Bool@+         * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'weak' @:: Lens' FieldOptions (Prelude.Maybe Prelude.Bool)@+         * 'Proto.Google.Protobuf.Descriptor_Fields.uninterpretedOption' @:: Lens' FieldOptions [UninterpretedOption]@+         * 'Proto.Google.Protobuf.Descriptor_Fields.vec'uninterpretedOption' @:: Lens' FieldOptions (Data.Vector.Vector UninterpretedOption)@ -}+data FieldOptions+  = FieldOptions'_constructor {_FieldOptions'ctype :: !(Prelude.Maybe FieldOptions'CType),+                               _FieldOptions'packed :: !(Prelude.Maybe Prelude.Bool),+                               _FieldOptions'jstype :: !(Prelude.Maybe FieldOptions'JSType),+                               _FieldOptions'lazy :: !(Prelude.Maybe Prelude.Bool),+                               _FieldOptions'deprecated :: !(Prelude.Maybe Prelude.Bool),+                               _FieldOptions'weak :: !(Prelude.Maybe Prelude.Bool),+                               _FieldOptions'uninterpretedOption :: !(Data.Vector.Vector UninterpretedOption),+                               _FieldOptions'_unknownFields :: !Data.ProtoLens.FieldSet}+  deriving (Prelude.Eq, Prelude.Ord)+instance Prelude.Show FieldOptions where+  showsPrec _ __x __s+    = Prelude.showChar+        '{'+        (Prelude.showString+           (Data.ProtoLens.showMessageShort __x) (Prelude.showChar '}' __s))+instance Data.ProtoLens.Field.HasField FieldOptions "ctype" FieldOptions'CType where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _FieldOptions'ctype (\ x__ y__ -> x__ {_FieldOptions'ctype = y__}))+        (Data.ProtoLens.maybeLens FieldOptions'STRING)+instance Data.ProtoLens.Field.HasField FieldOptions "maybe'ctype" (Prelude.Maybe FieldOptions'CType) where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _FieldOptions'ctype (\ x__ y__ -> x__ {_FieldOptions'ctype = y__}))+        Prelude.id+instance Data.ProtoLens.Field.HasField FieldOptions "packed" Prelude.Bool where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _FieldOptions'packed+           (\ x__ y__ -> x__ {_FieldOptions'packed = y__}))+        (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault)+instance Data.ProtoLens.Field.HasField FieldOptions "maybe'packed" (Prelude.Maybe Prelude.Bool) where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _FieldOptions'packed+           (\ x__ y__ -> x__ {_FieldOptions'packed = y__}))+        Prelude.id+instance Data.ProtoLens.Field.HasField FieldOptions "jstype" FieldOptions'JSType where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _FieldOptions'jstype+           (\ x__ y__ -> x__ {_FieldOptions'jstype = y__}))+        (Data.ProtoLens.maybeLens FieldOptions'JS_NORMAL)+instance Data.ProtoLens.Field.HasField FieldOptions "maybe'jstype" (Prelude.Maybe FieldOptions'JSType) where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _FieldOptions'jstype+           (\ x__ y__ -> x__ {_FieldOptions'jstype = y__}))+        Prelude.id+instance Data.ProtoLens.Field.HasField FieldOptions "lazy" Prelude.Bool where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _FieldOptions'lazy (\ x__ y__ -> x__ {_FieldOptions'lazy = y__}))+        (Data.ProtoLens.maybeLens Prelude.False)+instance Data.ProtoLens.Field.HasField FieldOptions "maybe'lazy" (Prelude.Maybe Prelude.Bool) where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _FieldOptions'lazy (\ x__ y__ -> x__ {_FieldOptions'lazy = y__}))+        Prelude.id+instance Data.ProtoLens.Field.HasField FieldOptions "deprecated" Prelude.Bool where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _FieldOptions'deprecated+           (\ x__ y__ -> x__ {_FieldOptions'deprecated = y__}))+        (Data.ProtoLens.maybeLens Prelude.False)+instance Data.ProtoLens.Field.HasField FieldOptions "maybe'deprecated" (Prelude.Maybe Prelude.Bool) where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _FieldOptions'deprecated+           (\ x__ y__ -> x__ {_FieldOptions'deprecated = y__}))+        Prelude.id+instance Data.ProtoLens.Field.HasField FieldOptions "weak" Prelude.Bool where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _FieldOptions'weak (\ x__ y__ -> x__ {_FieldOptions'weak = y__}))+        (Data.ProtoLens.maybeLens Prelude.False)+instance Data.ProtoLens.Field.HasField FieldOptions "maybe'weak" (Prelude.Maybe Prelude.Bool) where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _FieldOptions'weak (\ x__ y__ -> x__ {_FieldOptions'weak = y__}))+        Prelude.id+instance Data.ProtoLens.Field.HasField FieldOptions "uninterpretedOption" [UninterpretedOption] where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _FieldOptions'uninterpretedOption+           (\ x__ y__ -> x__ {_FieldOptions'uninterpretedOption = y__}))+        (Lens.Family2.Unchecked.lens+           Data.Vector.Generic.toList+           (\ _ y__ -> Data.Vector.Generic.fromList y__))+instance Data.ProtoLens.Field.HasField FieldOptions "vec'uninterpretedOption" (Data.Vector.Vector UninterpretedOption) where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _FieldOptions'uninterpretedOption+           (\ x__ y__ -> x__ {_FieldOptions'uninterpretedOption = y__}))+        Prelude.id+instance Data.ProtoLens.Message FieldOptions where+  messageName _ = Data.Text.pack "google.protobuf.FieldOptions"+  fieldsByTag+    = let+        ctype__field_descriptor+          = Data.ProtoLens.FieldDescriptor+              "ctype"+              (Data.ProtoLens.ScalarField Data.ProtoLens.EnumField ::+                 Data.ProtoLens.FieldTypeDescriptor FieldOptions'CType)+              (Data.ProtoLens.OptionalField+                 (Data.ProtoLens.Field.field @"maybe'ctype")) ::+              Data.ProtoLens.FieldDescriptor FieldOptions+        packed__field_descriptor+          = Data.ProtoLens.FieldDescriptor+              "packed"+              (Data.ProtoLens.ScalarField Data.ProtoLens.BoolField ::+                 Data.ProtoLens.FieldTypeDescriptor Prelude.Bool)+              (Data.ProtoLens.OptionalField+                 (Data.ProtoLens.Field.field @"maybe'packed")) ::+              Data.ProtoLens.FieldDescriptor FieldOptions+        jstype__field_descriptor+          = Data.ProtoLens.FieldDescriptor+              "jstype"+              (Data.ProtoLens.ScalarField Data.ProtoLens.EnumField ::+                 Data.ProtoLens.FieldTypeDescriptor FieldOptions'JSType)+              (Data.ProtoLens.OptionalField+                 (Data.ProtoLens.Field.field @"maybe'jstype")) ::+              Data.ProtoLens.FieldDescriptor FieldOptions+        lazy__field_descriptor+          = Data.ProtoLens.FieldDescriptor+              "lazy"+              (Data.ProtoLens.ScalarField Data.ProtoLens.BoolField ::+                 Data.ProtoLens.FieldTypeDescriptor Prelude.Bool)+              (Data.ProtoLens.OptionalField+                 (Data.ProtoLens.Field.field @"maybe'lazy")) ::+              Data.ProtoLens.FieldDescriptor FieldOptions+        deprecated__field_descriptor+          = Data.ProtoLens.FieldDescriptor+              "deprecated"+              (Data.ProtoLens.ScalarField Data.ProtoLens.BoolField ::+                 Data.ProtoLens.FieldTypeDescriptor Prelude.Bool)+              (Data.ProtoLens.OptionalField+                 (Data.ProtoLens.Field.field @"maybe'deprecated")) ::+              Data.ProtoLens.FieldDescriptor FieldOptions+        weak__field_descriptor+          = Data.ProtoLens.FieldDescriptor+              "weak"+              (Data.ProtoLens.ScalarField Data.ProtoLens.BoolField ::+                 Data.ProtoLens.FieldTypeDescriptor Prelude.Bool)+              (Data.ProtoLens.OptionalField+                 (Data.ProtoLens.Field.field @"maybe'weak")) ::+              Data.ProtoLens.FieldDescriptor FieldOptions+        uninterpretedOption__field_descriptor+          = Data.ProtoLens.FieldDescriptor+              "uninterpreted_option"+              (Data.ProtoLens.MessageField Data.ProtoLens.MessageType ::+                 Data.ProtoLens.FieldTypeDescriptor UninterpretedOption)+              (Data.ProtoLens.RepeatedField+                 Data.ProtoLens.Unpacked+                 (Data.ProtoLens.Field.field @"uninterpretedOption")) ::+              Data.ProtoLens.FieldDescriptor FieldOptions+      in+        Data.Map.fromList+          [(Data.ProtoLens.Tag 1, ctype__field_descriptor),+           (Data.ProtoLens.Tag 2, packed__field_descriptor),+           (Data.ProtoLens.Tag 6, jstype__field_descriptor),+           (Data.ProtoLens.Tag 5, lazy__field_descriptor),+           (Data.ProtoLens.Tag 3, deprecated__field_descriptor),+           (Data.ProtoLens.Tag 10, weak__field_descriptor),+           (Data.ProtoLens.Tag 999, uninterpretedOption__field_descriptor)]+  unknownFields+    = Lens.Family2.Unchecked.lens+        _FieldOptions'_unknownFields+        (\ x__ y__ -> x__ {_FieldOptions'_unknownFields = y__})+  defMessage+    = FieldOptions'_constructor+        {_FieldOptions'ctype = Prelude.Nothing,+         _FieldOptions'packed = Prelude.Nothing,+         _FieldOptions'jstype = Prelude.Nothing,+         _FieldOptions'lazy = Prelude.Nothing,+         _FieldOptions'deprecated = Prelude.Nothing,+         _FieldOptions'weak = Prelude.Nothing,+         _FieldOptions'uninterpretedOption = Data.Vector.Generic.empty,+         _FieldOptions'_unknownFields = []}+  parseMessage+    = let+        loop ::+          FieldOptions+          -> Data.ProtoLens.Encoding.Growing.Growing Data.Vector.Vector Data.ProtoLens.Encoding.Growing.RealWorld UninterpretedOption+             -> Data.ProtoLens.Encoding.Bytes.Parser FieldOptions+        loop x mutable'uninterpretedOption+          = do end <- Data.ProtoLens.Encoding.Bytes.atEnd+               if end then+                   do frozen'uninterpretedOption <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO+                                                      (Data.ProtoLens.Encoding.Growing.unsafeFreeze+                                                         mutable'uninterpretedOption)+                      (let missing = []+                       in+                         if Prelude.null missing then+                             Prelude.return ()+                         else+                             Prelude.fail+                               ((Prelude.++)+                                  "Missing required fields: "+                                  (Prelude.show (missing :: [Prelude.String]))))+                      Prelude.return+                        (Lens.Family2.over+                           Data.ProtoLens.unknownFields+                           (\ !t -> Prelude.reverse t)+                           (Lens.Family2.set+                              (Data.ProtoLens.Field.field @"vec'uninterpretedOption")+                              frozen'uninterpretedOption+                              x))+               else+                   do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt+                      case tag of+                        8 -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)+                                       (Prelude.fmap+                                          Prelude.toEnum+                                          (Prelude.fmap+                                             Prelude.fromIntegral+                                             Data.ProtoLens.Encoding.Bytes.getVarInt))+                                       "ctype"+                                loop+                                  (Lens.Family2.set (Data.ProtoLens.Field.field @"ctype") y x)+                                  mutable'uninterpretedOption+                        16+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)+                                       (Prelude.fmap+                                          ((Prelude./=) 0) Data.ProtoLens.Encoding.Bytes.getVarInt)+                                       "packed"+                                loop+                                  (Lens.Family2.set (Data.ProtoLens.Field.field @"packed") y x)+                                  mutable'uninterpretedOption+                        48+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)+                                       (Prelude.fmap+                                          Prelude.toEnum+                                          (Prelude.fmap+                                             Prelude.fromIntegral+                                             Data.ProtoLens.Encoding.Bytes.getVarInt))+                                       "jstype"+                                loop+                                  (Lens.Family2.set (Data.ProtoLens.Field.field @"jstype") y x)+                                  mutable'uninterpretedOption+                        40+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)+                                       (Prelude.fmap+                                          ((Prelude./=) 0) Data.ProtoLens.Encoding.Bytes.getVarInt)+                                       "lazy"+                                loop+                                  (Lens.Family2.set (Data.ProtoLens.Field.field @"lazy") y x)+                                  mutable'uninterpretedOption+                        24+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)+                                       (Prelude.fmap+                                          ((Prelude./=) 0) Data.ProtoLens.Encoding.Bytes.getVarInt)+                                       "deprecated"+                                loop+                                  (Lens.Family2.set (Data.ProtoLens.Field.field @"deprecated") y x)+                                  mutable'uninterpretedOption+                        80+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)+                                       (Prelude.fmap+                                          ((Prelude./=) 0) Data.ProtoLens.Encoding.Bytes.getVarInt)+                                       "weak"+                                loop+                                  (Lens.Family2.set (Data.ProtoLens.Field.field @"weak") y x)+                                  mutable'uninterpretedOption+                        7994+                          -> do !y <- (Data.ProtoLens.Encoding.Bytes.<?>)+                                        (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt+                                            Data.ProtoLens.Encoding.Bytes.isolate+                                              (Prelude.fromIntegral len)+                                              Data.ProtoLens.parseMessage)+                                        "uninterpreted_option"+                                v <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO+                                       (Data.ProtoLens.Encoding.Growing.append+                                          mutable'uninterpretedOption y)+                                loop x v+                        wire+                          -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire+                                        wire+                                loop+                                  (Lens.Family2.over+                                     Data.ProtoLens.unknownFields (\ !t -> (:) y t) x)+                                  mutable'uninterpretedOption+      in+        (Data.ProtoLens.Encoding.Bytes.<?>)+          (do mutable'uninterpretedOption <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO+                                               Data.ProtoLens.Encoding.Growing.new+              loop Data.ProtoLens.defMessage mutable'uninterpretedOption)+          "FieldOptions"+  buildMessage+    = \ _x+        -> (Data.Monoid.<>)+             (case+                  Lens.Family2.view (Data.ProtoLens.Field.field @"maybe'ctype") _x+              of+                Prelude.Nothing -> Data.Monoid.mempty+                (Prelude.Just _v)+                  -> (Data.Monoid.<>)+                       (Data.ProtoLens.Encoding.Bytes.putVarInt 8)+                       ((Prelude..)+                          ((Prelude..)+                             Data.ProtoLens.Encoding.Bytes.putVarInt Prelude.fromIntegral)+                          Prelude.fromEnum+                          _v))+             ((Data.Monoid.<>)+                (case+                     Lens.Family2.view (Data.ProtoLens.Field.field @"maybe'packed") _x+                 of+                   Prelude.Nothing -> Data.Monoid.mempty+                   (Prelude.Just _v)+                     -> (Data.Monoid.<>)+                          (Data.ProtoLens.Encoding.Bytes.putVarInt 16)+                          ((Prelude..)+                             Data.ProtoLens.Encoding.Bytes.putVarInt+                             (\ b -> if b then 1 else 0)+                             _v))+                ((Data.Monoid.<>)+                   (case+                        Lens.Family2.view (Data.ProtoLens.Field.field @"maybe'jstype") _x+                    of+                      Prelude.Nothing -> Data.Monoid.mempty+                      (Prelude.Just _v)+                        -> (Data.Monoid.<>)+                             (Data.ProtoLens.Encoding.Bytes.putVarInt 48)+                             ((Prelude..)+                                ((Prelude..)+                                   Data.ProtoLens.Encoding.Bytes.putVarInt Prelude.fromIntegral)+                                Prelude.fromEnum+                                _v))+                   ((Data.Monoid.<>)+                      (case+                           Lens.Family2.view (Data.ProtoLens.Field.field @"maybe'lazy") _x+                       of+                         Prelude.Nothing -> Data.Monoid.mempty+                         (Prelude.Just _v)+                           -> (Data.Monoid.<>)+                                (Data.ProtoLens.Encoding.Bytes.putVarInt 40)+                                ((Prelude..)+                                   Data.ProtoLens.Encoding.Bytes.putVarInt+                                   (\ b -> if b then 1 else 0)+                                   _v))+                      ((Data.Monoid.<>)+                         (case+                              Lens.Family2.view+                                (Data.ProtoLens.Field.field @"maybe'deprecated") _x+                          of+                            Prelude.Nothing -> Data.Monoid.mempty+                            (Prelude.Just _v)+                              -> (Data.Monoid.<>)+                                   (Data.ProtoLens.Encoding.Bytes.putVarInt 24)+                                   ((Prelude..)+                                      Data.ProtoLens.Encoding.Bytes.putVarInt+                                      (\ b -> if b then 1 else 0)+                                      _v))+                         ((Data.Monoid.<>)+                            (case+                                 Lens.Family2.view (Data.ProtoLens.Field.field @"maybe'weak") _x+                             of+                               Prelude.Nothing -> Data.Monoid.mempty+                               (Prelude.Just _v)+                                 -> (Data.Monoid.<>)+                                      (Data.ProtoLens.Encoding.Bytes.putVarInt 80)+                                      ((Prelude..)+                                         Data.ProtoLens.Encoding.Bytes.putVarInt+                                         (\ b -> if b then 1 else 0)+                                         _v))+                            ((Data.Monoid.<>)+                               (Data.ProtoLens.Encoding.Bytes.foldMapBuilder+                                  (\ _v+                                     -> (Data.Monoid.<>)+                                          (Data.ProtoLens.Encoding.Bytes.putVarInt 7994)+                                          ((Prelude..)+                                             (\ bs+                                                -> (Data.Monoid.<>)+                                                     (Data.ProtoLens.Encoding.Bytes.putVarInt+                                                        (Prelude.fromIntegral+                                                           (Data.ByteString.length bs)))+                                                     (Data.ProtoLens.Encoding.Bytes.putBytes bs))+                                             Data.ProtoLens.encodeMessage+                                             _v))+                                  (Lens.Family2.view+                                     (Data.ProtoLens.Field.field @"vec'uninterpretedOption") _x))+                               (Data.ProtoLens.Encoding.Wire.buildFieldSet+                                  (Lens.Family2.view Data.ProtoLens.unknownFields _x))))))))+instance Control.DeepSeq.NFData FieldOptions where+  rnf+    = \ x__+        -> Control.DeepSeq.deepseq+             (_FieldOptions'_unknownFields x__)+             (Control.DeepSeq.deepseq+                (_FieldOptions'ctype x__)+                (Control.DeepSeq.deepseq+                   (_FieldOptions'packed x__)+                   (Control.DeepSeq.deepseq+                      (_FieldOptions'jstype x__)+                      (Control.DeepSeq.deepseq+                         (_FieldOptions'lazy x__)+                         (Control.DeepSeq.deepseq+                            (_FieldOptions'deprecated x__)+                            (Control.DeepSeq.deepseq+                               (_FieldOptions'weak x__)+                               (Control.DeepSeq.deepseq+                                  (_FieldOptions'uninterpretedOption x__) ())))))))+data FieldOptions'CType+  = FieldOptions'STRING |+    FieldOptions'CORD |+    FieldOptions'STRING_PIECE+  deriving (Prelude.Show, Prelude.Eq, Prelude.Ord)+instance Data.ProtoLens.MessageEnum FieldOptions'CType where+  maybeToEnum 0 = Prelude.Just FieldOptions'STRING+  maybeToEnum 1 = Prelude.Just FieldOptions'CORD+  maybeToEnum 2 = Prelude.Just FieldOptions'STRING_PIECE+  maybeToEnum _ = Prelude.Nothing+  showEnum FieldOptions'STRING = "STRING"+  showEnum FieldOptions'CORD = "CORD"+  showEnum FieldOptions'STRING_PIECE = "STRING_PIECE"+  readEnum k+    | (Prelude.==) k "STRING" = Prelude.Just FieldOptions'STRING+    | (Prelude.==) k "CORD" = Prelude.Just FieldOptions'CORD+    | (Prelude.==) k "STRING_PIECE"+    = Prelude.Just FieldOptions'STRING_PIECE+    | Prelude.otherwise+    = (Prelude.>>=) (Text.Read.readMaybe k) Data.ProtoLens.maybeToEnum+instance Prelude.Bounded FieldOptions'CType where+  minBound = FieldOptions'STRING+  maxBound = FieldOptions'STRING_PIECE+instance Prelude.Enum FieldOptions'CType where+  toEnum k__+    = Prelude.maybe+        (Prelude.error+           ((Prelude.++)+              "toEnum: unknown value for enum CType: " (Prelude.show k__)))+        Prelude.id+        (Data.ProtoLens.maybeToEnum k__)+  fromEnum FieldOptions'STRING = 0+  fromEnum FieldOptions'CORD = 1+  fromEnum FieldOptions'STRING_PIECE = 2+  succ FieldOptions'STRING_PIECE+    = Prelude.error+        "FieldOptions'CType.succ: bad argument FieldOptions'STRING_PIECE. This value would be out of bounds."+  succ FieldOptions'STRING = FieldOptions'CORD+  succ FieldOptions'CORD = FieldOptions'STRING_PIECE+  pred FieldOptions'STRING+    = Prelude.error+        "FieldOptions'CType.pred: bad argument FieldOptions'STRING. This value would be out of bounds."+  pred FieldOptions'CORD = FieldOptions'STRING+  pred FieldOptions'STRING_PIECE = FieldOptions'CORD+  enumFrom = Data.ProtoLens.Message.Enum.messageEnumFrom+  enumFromTo = Data.ProtoLens.Message.Enum.messageEnumFromTo+  enumFromThen = Data.ProtoLens.Message.Enum.messageEnumFromThen+  enumFromThenTo = Data.ProtoLens.Message.Enum.messageEnumFromThenTo+instance Data.ProtoLens.FieldDefault FieldOptions'CType where+  fieldDefault = FieldOptions'STRING+instance Control.DeepSeq.NFData FieldOptions'CType where+  rnf x__ = Prelude.seq x__ ()+data FieldOptions'JSType+  = FieldOptions'JS_NORMAL |+    FieldOptions'JS_STRING |+    FieldOptions'JS_NUMBER+  deriving (Prelude.Show, Prelude.Eq, Prelude.Ord)+instance Data.ProtoLens.MessageEnum FieldOptions'JSType where+  maybeToEnum 0 = Prelude.Just FieldOptions'JS_NORMAL+  maybeToEnum 1 = Prelude.Just FieldOptions'JS_STRING+  maybeToEnum 2 = Prelude.Just FieldOptions'JS_NUMBER+  maybeToEnum _ = Prelude.Nothing+  showEnum FieldOptions'JS_NORMAL = "JS_NORMAL"+  showEnum FieldOptions'JS_STRING = "JS_STRING"+  showEnum FieldOptions'JS_NUMBER = "JS_NUMBER"+  readEnum k+    | (Prelude.==) k "JS_NORMAL" = Prelude.Just FieldOptions'JS_NORMAL+    | (Prelude.==) k "JS_STRING" = Prelude.Just FieldOptions'JS_STRING+    | (Prelude.==) k "JS_NUMBER" = Prelude.Just FieldOptions'JS_NUMBER+    | Prelude.otherwise+    = (Prelude.>>=) (Text.Read.readMaybe k) Data.ProtoLens.maybeToEnum+instance Prelude.Bounded FieldOptions'JSType where+  minBound = FieldOptions'JS_NORMAL+  maxBound = FieldOptions'JS_NUMBER+instance Prelude.Enum FieldOptions'JSType where+  toEnum k__+    = Prelude.maybe+        (Prelude.error+           ((Prelude.++)+              "toEnum: unknown value for enum JSType: " (Prelude.show k__)))+        Prelude.id+        (Data.ProtoLens.maybeToEnum k__)+  fromEnum FieldOptions'JS_NORMAL = 0+  fromEnum FieldOptions'JS_STRING = 1+  fromEnum FieldOptions'JS_NUMBER = 2+  succ FieldOptions'JS_NUMBER+    = Prelude.error+        "FieldOptions'JSType.succ: bad argument FieldOptions'JS_NUMBER. This value would be out of bounds."+  succ FieldOptions'JS_NORMAL = FieldOptions'JS_STRING+  succ FieldOptions'JS_STRING = FieldOptions'JS_NUMBER+  pred FieldOptions'JS_NORMAL+    = Prelude.error+        "FieldOptions'JSType.pred: bad argument FieldOptions'JS_NORMAL. This value would be out of bounds."+  pred FieldOptions'JS_STRING = FieldOptions'JS_NORMAL+  pred FieldOptions'JS_NUMBER = FieldOptions'JS_STRING+  enumFrom = Data.ProtoLens.Message.Enum.messageEnumFrom+  enumFromTo = Data.ProtoLens.Message.Enum.messageEnumFromTo+  enumFromThen = Data.ProtoLens.Message.Enum.messageEnumFromThen+  enumFromThenTo = Data.ProtoLens.Message.Enum.messageEnumFromThenTo+instance Data.ProtoLens.FieldDefault FieldOptions'JSType where+  fieldDefault = FieldOptions'JS_NORMAL+instance Control.DeepSeq.NFData FieldOptions'JSType where+  rnf x__ = Prelude.seq x__ ()+{- | Fields :+     +         * 'Proto.Google.Protobuf.Descriptor_Fields.name' @:: Lens' FileDescriptorProto Data.Text.Text@+         * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'name' @:: Lens' FileDescriptorProto (Prelude.Maybe Data.Text.Text)@+         * 'Proto.Google.Protobuf.Descriptor_Fields.package' @:: Lens' FileDescriptorProto Data.Text.Text@+         * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'package' @:: Lens' FileDescriptorProto (Prelude.Maybe Data.Text.Text)@+         * 'Proto.Google.Protobuf.Descriptor_Fields.dependency' @:: Lens' FileDescriptorProto [Data.Text.Text]@+         * 'Proto.Google.Protobuf.Descriptor_Fields.vec'dependency' @:: Lens' FileDescriptorProto (Data.Vector.Vector Data.Text.Text)@+         * 'Proto.Google.Protobuf.Descriptor_Fields.publicDependency' @:: Lens' FileDescriptorProto [Data.Int.Int32]@+         * 'Proto.Google.Protobuf.Descriptor_Fields.vec'publicDependency' @:: Lens' FileDescriptorProto (Data.Vector.Unboxed.Vector Data.Int.Int32)@+         * 'Proto.Google.Protobuf.Descriptor_Fields.weakDependency' @:: Lens' FileDescriptorProto [Data.Int.Int32]@+         * 'Proto.Google.Protobuf.Descriptor_Fields.vec'weakDependency' @:: Lens' FileDescriptorProto (Data.Vector.Unboxed.Vector Data.Int.Int32)@+         * 'Proto.Google.Protobuf.Descriptor_Fields.messageType' @:: Lens' FileDescriptorProto [DescriptorProto]@+         * 'Proto.Google.Protobuf.Descriptor_Fields.vec'messageType' @:: Lens' FileDescriptorProto (Data.Vector.Vector DescriptorProto)@+         * 'Proto.Google.Protobuf.Descriptor_Fields.enumType' @:: Lens' FileDescriptorProto [EnumDescriptorProto]@+         * 'Proto.Google.Protobuf.Descriptor_Fields.vec'enumType' @:: Lens' FileDescriptorProto (Data.Vector.Vector EnumDescriptorProto)@+         * 'Proto.Google.Protobuf.Descriptor_Fields.service' @:: Lens' FileDescriptorProto [ServiceDescriptorProto]@+         * 'Proto.Google.Protobuf.Descriptor_Fields.vec'service' @:: Lens' FileDescriptorProto (Data.Vector.Vector ServiceDescriptorProto)@+         * 'Proto.Google.Protobuf.Descriptor_Fields.extension' @:: Lens' FileDescriptorProto [FieldDescriptorProto]@+         * 'Proto.Google.Protobuf.Descriptor_Fields.vec'extension' @:: Lens' FileDescriptorProto (Data.Vector.Vector FieldDescriptorProto)@+         * 'Proto.Google.Protobuf.Descriptor_Fields.options' @:: Lens' FileDescriptorProto FileOptions@+         * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'options' @:: Lens' FileDescriptorProto (Prelude.Maybe FileOptions)@+         * 'Proto.Google.Protobuf.Descriptor_Fields.sourceCodeInfo' @:: Lens' FileDescriptorProto SourceCodeInfo@+         * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'sourceCodeInfo' @:: Lens' FileDescriptorProto (Prelude.Maybe SourceCodeInfo)@+         * 'Proto.Google.Protobuf.Descriptor_Fields.syntax' @:: Lens' FileDescriptorProto Data.Text.Text@+         * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'syntax' @:: Lens' FileDescriptorProto (Prelude.Maybe Data.Text.Text)@ -}+data FileDescriptorProto+  = FileDescriptorProto'_constructor {_FileDescriptorProto'name :: !(Prelude.Maybe Data.Text.Text),+                                      _FileDescriptorProto'package :: !(Prelude.Maybe Data.Text.Text),+                                      _FileDescriptorProto'dependency :: !(Data.Vector.Vector Data.Text.Text),+                                      _FileDescriptorProto'publicDependency :: !(Data.Vector.Unboxed.Vector Data.Int.Int32),+                                      _FileDescriptorProto'weakDependency :: !(Data.Vector.Unboxed.Vector Data.Int.Int32),+                                      _FileDescriptorProto'messageType :: !(Data.Vector.Vector DescriptorProto),+                                      _FileDescriptorProto'enumType :: !(Data.Vector.Vector EnumDescriptorProto),+                                      _FileDescriptorProto'service :: !(Data.Vector.Vector ServiceDescriptorProto),+                                      _FileDescriptorProto'extension :: !(Data.Vector.Vector FieldDescriptorProto),+                                      _FileDescriptorProto'options :: !(Prelude.Maybe FileOptions),+                                      _FileDescriptorProto'sourceCodeInfo :: !(Prelude.Maybe SourceCodeInfo),+                                      _FileDescriptorProto'syntax :: !(Prelude.Maybe Data.Text.Text),+                                      _FileDescriptorProto'_unknownFields :: !Data.ProtoLens.FieldSet}+  deriving (Prelude.Eq, Prelude.Ord)+instance Prelude.Show FileDescriptorProto where+  showsPrec _ __x __s+    = Prelude.showChar+        '{'+        (Prelude.showString+           (Data.ProtoLens.showMessageShort __x) (Prelude.showChar '}' __s))+instance Data.ProtoLens.Field.HasField FileDescriptorProto "name" Data.Text.Text where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _FileDescriptorProto'name+           (\ x__ y__ -> x__ {_FileDescriptorProto'name = y__}))+        (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault)+instance Data.ProtoLens.Field.HasField FileDescriptorProto "maybe'name" (Prelude.Maybe Data.Text.Text) where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _FileDescriptorProto'name+           (\ x__ y__ -> x__ {_FileDescriptorProto'name = y__}))+        Prelude.id+instance Data.ProtoLens.Field.HasField FileDescriptorProto "package" Data.Text.Text where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _FileDescriptorProto'package+           (\ x__ y__ -> x__ {_FileDescriptorProto'package = y__}))+        (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault)+instance Data.ProtoLens.Field.HasField FileDescriptorProto "maybe'package" (Prelude.Maybe Data.Text.Text) where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _FileDescriptorProto'package+           (\ x__ y__ -> x__ {_FileDescriptorProto'package = y__}))+        Prelude.id+instance Data.ProtoLens.Field.HasField FileDescriptorProto "dependency" [Data.Text.Text] where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _FileDescriptorProto'dependency+           (\ x__ y__ -> x__ {_FileDescriptorProto'dependency = y__}))+        (Lens.Family2.Unchecked.lens+           Data.Vector.Generic.toList+           (\ _ y__ -> Data.Vector.Generic.fromList y__))+instance Data.ProtoLens.Field.HasField FileDescriptorProto "vec'dependency" (Data.Vector.Vector Data.Text.Text) where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _FileDescriptorProto'dependency+           (\ x__ y__ -> x__ {_FileDescriptorProto'dependency = y__}))+        Prelude.id+instance Data.ProtoLens.Field.HasField FileDescriptorProto "publicDependency" [Data.Int.Int32] where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _FileDescriptorProto'publicDependency+           (\ x__ y__ -> x__ {_FileDescriptorProto'publicDependency = y__}))+        (Lens.Family2.Unchecked.lens+           Data.Vector.Generic.toList+           (\ _ y__ -> Data.Vector.Generic.fromList y__))+instance Data.ProtoLens.Field.HasField FileDescriptorProto "vec'publicDependency" (Data.Vector.Unboxed.Vector Data.Int.Int32) where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _FileDescriptorProto'publicDependency+           (\ x__ y__ -> x__ {_FileDescriptorProto'publicDependency = y__}))+        Prelude.id+instance Data.ProtoLens.Field.HasField FileDescriptorProto "weakDependency" [Data.Int.Int32] where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _FileDescriptorProto'weakDependency+           (\ x__ y__ -> x__ {_FileDescriptorProto'weakDependency = y__}))+        (Lens.Family2.Unchecked.lens+           Data.Vector.Generic.toList+           (\ _ y__ -> Data.Vector.Generic.fromList y__))+instance Data.ProtoLens.Field.HasField FileDescriptorProto "vec'weakDependency" (Data.Vector.Unboxed.Vector Data.Int.Int32) where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _FileDescriptorProto'weakDependency+           (\ x__ y__ -> x__ {_FileDescriptorProto'weakDependency = y__}))+        Prelude.id+instance Data.ProtoLens.Field.HasField FileDescriptorProto "messageType" [DescriptorProto] where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _FileDescriptorProto'messageType+           (\ x__ y__ -> x__ {_FileDescriptorProto'messageType = y__}))+        (Lens.Family2.Unchecked.lens+           Data.Vector.Generic.toList+           (\ _ y__ -> Data.Vector.Generic.fromList y__))+instance Data.ProtoLens.Field.HasField FileDescriptorProto "vec'messageType" (Data.Vector.Vector DescriptorProto) where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _FileDescriptorProto'messageType+           (\ x__ y__ -> x__ {_FileDescriptorProto'messageType = y__}))+        Prelude.id+instance Data.ProtoLens.Field.HasField FileDescriptorProto "enumType" [EnumDescriptorProto] where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _FileDescriptorProto'enumType+           (\ x__ y__ -> x__ {_FileDescriptorProto'enumType = y__}))+        (Lens.Family2.Unchecked.lens+           Data.Vector.Generic.toList+           (\ _ y__ -> Data.Vector.Generic.fromList y__))+instance Data.ProtoLens.Field.HasField FileDescriptorProto "vec'enumType" (Data.Vector.Vector EnumDescriptorProto) where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _FileDescriptorProto'enumType+           (\ x__ y__ -> x__ {_FileDescriptorProto'enumType = y__}))+        Prelude.id+instance Data.ProtoLens.Field.HasField FileDescriptorProto "service" [ServiceDescriptorProto] where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _FileDescriptorProto'service+           (\ x__ y__ -> x__ {_FileDescriptorProto'service = y__}))+        (Lens.Family2.Unchecked.lens+           Data.Vector.Generic.toList+           (\ _ y__ -> Data.Vector.Generic.fromList y__))+instance Data.ProtoLens.Field.HasField FileDescriptorProto "vec'service" (Data.Vector.Vector ServiceDescriptorProto) where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _FileDescriptorProto'service+           (\ x__ y__ -> x__ {_FileDescriptorProto'service = y__}))+        Prelude.id+instance Data.ProtoLens.Field.HasField FileDescriptorProto "extension" [FieldDescriptorProto] where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _FileDescriptorProto'extension+           (\ x__ y__ -> x__ {_FileDescriptorProto'extension = y__}))+        (Lens.Family2.Unchecked.lens+           Data.Vector.Generic.toList+           (\ _ y__ -> Data.Vector.Generic.fromList y__))+instance Data.ProtoLens.Field.HasField FileDescriptorProto "vec'extension" (Data.Vector.Vector FieldDescriptorProto) where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _FileDescriptorProto'extension+           (\ x__ y__ -> x__ {_FileDescriptorProto'extension = y__}))+        Prelude.id+instance Data.ProtoLens.Field.HasField FileDescriptorProto "options" FileOptions where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _FileDescriptorProto'options+           (\ x__ y__ -> x__ {_FileDescriptorProto'options = y__}))+        (Data.ProtoLens.maybeLens Data.ProtoLens.defMessage)+instance Data.ProtoLens.Field.HasField FileDescriptorProto "maybe'options" (Prelude.Maybe FileOptions) where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _FileDescriptorProto'options+           (\ x__ y__ -> x__ {_FileDescriptorProto'options = y__}))+        Prelude.id+instance Data.ProtoLens.Field.HasField FileDescriptorProto "sourceCodeInfo" SourceCodeInfo where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _FileDescriptorProto'sourceCodeInfo+           (\ x__ y__ -> x__ {_FileDescriptorProto'sourceCodeInfo = y__}))+        (Data.ProtoLens.maybeLens Data.ProtoLens.defMessage)+instance Data.ProtoLens.Field.HasField FileDescriptorProto "maybe'sourceCodeInfo" (Prelude.Maybe SourceCodeInfo) where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _FileDescriptorProto'sourceCodeInfo+           (\ x__ y__ -> x__ {_FileDescriptorProto'sourceCodeInfo = y__}))+        Prelude.id+instance Data.ProtoLens.Field.HasField FileDescriptorProto "syntax" Data.Text.Text where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _FileDescriptorProto'syntax+           (\ x__ y__ -> x__ {_FileDescriptorProto'syntax = y__}))+        (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault)+instance Data.ProtoLens.Field.HasField FileDescriptorProto "maybe'syntax" (Prelude.Maybe Data.Text.Text) where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _FileDescriptorProto'syntax+           (\ x__ y__ -> x__ {_FileDescriptorProto'syntax = y__}))+        Prelude.id+instance Data.ProtoLens.Message FileDescriptorProto where+  messageName _+    = Data.Text.pack "google.protobuf.FileDescriptorProto"+  fieldsByTag+    = let+        name__field_descriptor+          = Data.ProtoLens.FieldDescriptor+              "name"+              (Data.ProtoLens.ScalarField Data.ProtoLens.StringField ::+                 Data.ProtoLens.FieldTypeDescriptor Data.Text.Text)+              (Data.ProtoLens.OptionalField+                 (Data.ProtoLens.Field.field @"maybe'name")) ::+              Data.ProtoLens.FieldDescriptor FileDescriptorProto+        package__field_descriptor+          = Data.ProtoLens.FieldDescriptor+              "package"+              (Data.ProtoLens.ScalarField Data.ProtoLens.StringField ::+                 Data.ProtoLens.FieldTypeDescriptor Data.Text.Text)+              (Data.ProtoLens.OptionalField+                 (Data.ProtoLens.Field.field @"maybe'package")) ::+              Data.ProtoLens.FieldDescriptor FileDescriptorProto+        dependency__field_descriptor+          = Data.ProtoLens.FieldDescriptor+              "dependency"+              (Data.ProtoLens.ScalarField Data.ProtoLens.StringField ::+                 Data.ProtoLens.FieldTypeDescriptor Data.Text.Text)+              (Data.ProtoLens.RepeatedField+                 Data.ProtoLens.Unpacked+                 (Data.ProtoLens.Field.field @"dependency")) ::+              Data.ProtoLens.FieldDescriptor FileDescriptorProto+        publicDependency__field_descriptor+          = Data.ProtoLens.FieldDescriptor+              "public_dependency"+              (Data.ProtoLens.ScalarField Data.ProtoLens.Int32Field ::+                 Data.ProtoLens.FieldTypeDescriptor Data.Int.Int32)+              (Data.ProtoLens.RepeatedField+                 Data.ProtoLens.Unpacked+                 (Data.ProtoLens.Field.field @"publicDependency")) ::+              Data.ProtoLens.FieldDescriptor FileDescriptorProto+        weakDependency__field_descriptor+          = Data.ProtoLens.FieldDescriptor+              "weak_dependency"+              (Data.ProtoLens.ScalarField Data.ProtoLens.Int32Field ::+                 Data.ProtoLens.FieldTypeDescriptor Data.Int.Int32)+              (Data.ProtoLens.RepeatedField+                 Data.ProtoLens.Unpacked+                 (Data.ProtoLens.Field.field @"weakDependency")) ::+              Data.ProtoLens.FieldDescriptor FileDescriptorProto+        messageType__field_descriptor+          = Data.ProtoLens.FieldDescriptor+              "message_type"+              (Data.ProtoLens.MessageField Data.ProtoLens.MessageType ::+                 Data.ProtoLens.FieldTypeDescriptor DescriptorProto)+              (Data.ProtoLens.RepeatedField+                 Data.ProtoLens.Unpacked+                 (Data.ProtoLens.Field.field @"messageType")) ::+              Data.ProtoLens.FieldDescriptor FileDescriptorProto+        enumType__field_descriptor+          = Data.ProtoLens.FieldDescriptor+              "enum_type"+              (Data.ProtoLens.MessageField Data.ProtoLens.MessageType ::+                 Data.ProtoLens.FieldTypeDescriptor EnumDescriptorProto)+              (Data.ProtoLens.RepeatedField+                 Data.ProtoLens.Unpacked+                 (Data.ProtoLens.Field.field @"enumType")) ::+              Data.ProtoLens.FieldDescriptor FileDescriptorProto+        service__field_descriptor+          = Data.ProtoLens.FieldDescriptor+              "service"+              (Data.ProtoLens.MessageField Data.ProtoLens.MessageType ::+                 Data.ProtoLens.FieldTypeDescriptor ServiceDescriptorProto)+              (Data.ProtoLens.RepeatedField+                 Data.ProtoLens.Unpacked (Data.ProtoLens.Field.field @"service")) ::+              Data.ProtoLens.FieldDescriptor FileDescriptorProto+        extension__field_descriptor+          = Data.ProtoLens.FieldDescriptor+              "extension"+              (Data.ProtoLens.MessageField Data.ProtoLens.MessageType ::+                 Data.ProtoLens.FieldTypeDescriptor FieldDescriptorProto)+              (Data.ProtoLens.RepeatedField+                 Data.ProtoLens.Unpacked+                 (Data.ProtoLens.Field.field @"extension")) ::+              Data.ProtoLens.FieldDescriptor FileDescriptorProto+        options__field_descriptor+          = Data.ProtoLens.FieldDescriptor+              "options"+              (Data.ProtoLens.MessageField Data.ProtoLens.MessageType ::+                 Data.ProtoLens.FieldTypeDescriptor FileOptions)+              (Data.ProtoLens.OptionalField+                 (Data.ProtoLens.Field.field @"maybe'options")) ::+              Data.ProtoLens.FieldDescriptor FileDescriptorProto+        sourceCodeInfo__field_descriptor+          = Data.ProtoLens.FieldDescriptor+              "source_code_info"+              (Data.ProtoLens.MessageField Data.ProtoLens.MessageType ::+                 Data.ProtoLens.FieldTypeDescriptor SourceCodeInfo)+              (Data.ProtoLens.OptionalField+                 (Data.ProtoLens.Field.field @"maybe'sourceCodeInfo")) ::+              Data.ProtoLens.FieldDescriptor FileDescriptorProto+        syntax__field_descriptor+          = Data.ProtoLens.FieldDescriptor+              "syntax"+              (Data.ProtoLens.ScalarField Data.ProtoLens.StringField ::+                 Data.ProtoLens.FieldTypeDescriptor Data.Text.Text)+              (Data.ProtoLens.OptionalField+                 (Data.ProtoLens.Field.field @"maybe'syntax")) ::+              Data.ProtoLens.FieldDescriptor FileDescriptorProto+      in+        Data.Map.fromList+          [(Data.ProtoLens.Tag 1, name__field_descriptor),+           (Data.ProtoLens.Tag 2, package__field_descriptor),+           (Data.ProtoLens.Tag 3, dependency__field_descriptor),+           (Data.ProtoLens.Tag 10, publicDependency__field_descriptor),+           (Data.ProtoLens.Tag 11, weakDependency__field_descriptor),+           (Data.ProtoLens.Tag 4, messageType__field_descriptor),+           (Data.ProtoLens.Tag 5, enumType__field_descriptor),+           (Data.ProtoLens.Tag 6, service__field_descriptor),+           (Data.ProtoLens.Tag 7, extension__field_descriptor),+           (Data.ProtoLens.Tag 8, options__field_descriptor),+           (Data.ProtoLens.Tag 9, sourceCodeInfo__field_descriptor),+           (Data.ProtoLens.Tag 12, syntax__field_descriptor)]+  unknownFields+    = Lens.Family2.Unchecked.lens+        _FileDescriptorProto'_unknownFields+        (\ x__ y__ -> x__ {_FileDescriptorProto'_unknownFields = y__})+  defMessage+    = FileDescriptorProto'_constructor+        {_FileDescriptorProto'name = Prelude.Nothing,+         _FileDescriptorProto'package = Prelude.Nothing,+         _FileDescriptorProto'dependency = Data.Vector.Generic.empty,+         _FileDescriptorProto'publicDependency = Data.Vector.Generic.empty,+         _FileDescriptorProto'weakDependency = Data.Vector.Generic.empty,+         _FileDescriptorProto'messageType = Data.Vector.Generic.empty,+         _FileDescriptorProto'enumType = Data.Vector.Generic.empty,+         _FileDescriptorProto'service = Data.Vector.Generic.empty,+         _FileDescriptorProto'extension = Data.Vector.Generic.empty,+         _FileDescriptorProto'options = Prelude.Nothing,+         _FileDescriptorProto'sourceCodeInfo = Prelude.Nothing,+         _FileDescriptorProto'syntax = Prelude.Nothing,+         _FileDescriptorProto'_unknownFields = []}+  parseMessage+    = let+        loop ::+          FileDescriptorProto+          -> Data.ProtoLens.Encoding.Growing.Growing Data.Vector.Vector Data.ProtoLens.Encoding.Growing.RealWorld Data.Text.Text+             -> Data.ProtoLens.Encoding.Growing.Growing Data.Vector.Vector Data.ProtoLens.Encoding.Growing.RealWorld EnumDescriptorProto+                -> Data.ProtoLens.Encoding.Growing.Growing Data.Vector.Vector Data.ProtoLens.Encoding.Growing.RealWorld FieldDescriptorProto+                   -> Data.ProtoLens.Encoding.Growing.Growing Data.Vector.Vector Data.ProtoLens.Encoding.Growing.RealWorld DescriptorProto+                      -> Data.ProtoLens.Encoding.Growing.Growing Data.Vector.Unboxed.Vector Data.ProtoLens.Encoding.Growing.RealWorld Data.Int.Int32+                         -> Data.ProtoLens.Encoding.Growing.Growing Data.Vector.Vector Data.ProtoLens.Encoding.Growing.RealWorld ServiceDescriptorProto+                            -> Data.ProtoLens.Encoding.Growing.Growing Data.Vector.Unboxed.Vector Data.ProtoLens.Encoding.Growing.RealWorld Data.Int.Int32+                               -> Data.ProtoLens.Encoding.Bytes.Parser FileDescriptorProto+        loop+          x+          mutable'dependency+          mutable'enumType+          mutable'extension+          mutable'messageType+          mutable'publicDependency+          mutable'service+          mutable'weakDependency+          = do end <- Data.ProtoLens.Encoding.Bytes.atEnd+               if end then+                   do frozen'dependency <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO+                                             (Data.ProtoLens.Encoding.Growing.unsafeFreeze+                                                mutable'dependency)+                      frozen'enumType <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO+                                           (Data.ProtoLens.Encoding.Growing.unsafeFreeze+                                              mutable'enumType)+                      frozen'extension <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO+                                            (Data.ProtoLens.Encoding.Growing.unsafeFreeze+                                               mutable'extension)+                      frozen'messageType <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO+                                              (Data.ProtoLens.Encoding.Growing.unsafeFreeze+                                                 mutable'messageType)+                      frozen'publicDependency <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO+                                                   (Data.ProtoLens.Encoding.Growing.unsafeFreeze+                                                      mutable'publicDependency)+                      frozen'service <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO+                                          (Data.ProtoLens.Encoding.Growing.unsafeFreeze+                                             mutable'service)+                      frozen'weakDependency <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO+                                                 (Data.ProtoLens.Encoding.Growing.unsafeFreeze+                                                    mutable'weakDependency)+                      (let missing = []+                       in+                         if Prelude.null missing then+                             Prelude.return ()+                         else+                             Prelude.fail+                               ((Prelude.++)+                                  "Missing required fields: "+                                  (Prelude.show (missing :: [Prelude.String]))))+                      Prelude.return+                        (Lens.Family2.over+                           Data.ProtoLens.unknownFields+                           (\ !t -> Prelude.reverse t)+                           (Lens.Family2.set+                              (Data.ProtoLens.Field.field @"vec'dependency")+                              frozen'dependency+                              (Lens.Family2.set+                                 (Data.ProtoLens.Field.field @"vec'enumType")+                                 frozen'enumType+                                 (Lens.Family2.set+                                    (Data.ProtoLens.Field.field @"vec'extension")+                                    frozen'extension+                                    (Lens.Family2.set+                                       (Data.ProtoLens.Field.field @"vec'messageType")+                                       frozen'messageType+                                       (Lens.Family2.set+                                          (Data.ProtoLens.Field.field @"vec'publicDependency")+                                          frozen'publicDependency+                                          (Lens.Family2.set+                                             (Data.ProtoLens.Field.field @"vec'service")+                                             frozen'service+                                             (Lens.Family2.set+                                                (Data.ProtoLens.Field.field @"vec'weakDependency")+                                                frozen'weakDependency+                                                x))))))))+               else+                   do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt+                      case tag of+                        10+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)+                                       (do value <- do len <- Data.ProtoLens.Encoding.Bytes.getVarInt+                                                       Data.ProtoLens.Encoding.Bytes.getBytes+                                                         (Prelude.fromIntegral len)+                                           Data.ProtoLens.Encoding.Bytes.runEither+                                             (case Data.Text.Encoding.decodeUtf8' value of+                                                (Prelude.Left err)+                                                  -> Prelude.Left (Prelude.show err)+                                                (Prelude.Right r) -> Prelude.Right r))+                                       "name"+                                loop+                                  (Lens.Family2.set (Data.ProtoLens.Field.field @"name") y x)+                                  mutable'dependency+                                  mutable'enumType+                                  mutable'extension+                                  mutable'messageType+                                  mutable'publicDependency+                                  mutable'service+                                  mutable'weakDependency+                        18+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)+                                       (do value <- do len <- Data.ProtoLens.Encoding.Bytes.getVarInt+                                                       Data.ProtoLens.Encoding.Bytes.getBytes+                                                         (Prelude.fromIntegral len)+                                           Data.ProtoLens.Encoding.Bytes.runEither+                                             (case Data.Text.Encoding.decodeUtf8' value of+                                                (Prelude.Left err)+                                                  -> Prelude.Left (Prelude.show err)+                                                (Prelude.Right r) -> Prelude.Right r))+                                       "package"+                                loop+                                  (Lens.Family2.set (Data.ProtoLens.Field.field @"package") y x)+                                  mutable'dependency+                                  mutable'enumType+                                  mutable'extension+                                  mutable'messageType+                                  mutable'publicDependency+                                  mutable'service+                                  mutable'weakDependency+                        26+                          -> do !y <- (Data.ProtoLens.Encoding.Bytes.<?>)+                                        (do value <- do len <- Data.ProtoLens.Encoding.Bytes.getVarInt+                                                        Data.ProtoLens.Encoding.Bytes.getBytes+                                                          (Prelude.fromIntegral len)+                                            Data.ProtoLens.Encoding.Bytes.runEither+                                              (case Data.Text.Encoding.decodeUtf8' value of+                                                 (Prelude.Left err)+                                                   -> Prelude.Left (Prelude.show err)+                                                 (Prelude.Right r) -> Prelude.Right r))+                                        "dependency"+                                v <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO+                                       (Data.ProtoLens.Encoding.Growing.append mutable'dependency y)+                                loop+                                  x+                                  v+                                  mutable'enumType+                                  mutable'extension+                                  mutable'messageType+                                  mutable'publicDependency+                                  mutable'service+                                  mutable'weakDependency+                        80+                          -> do !y <- (Data.ProtoLens.Encoding.Bytes.<?>)+                                        (Prelude.fmap+                                           Prelude.fromIntegral+                                           Data.ProtoLens.Encoding.Bytes.getVarInt)+                                        "public_dependency"+                                v <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO+                                       (Data.ProtoLens.Encoding.Growing.append+                                          mutable'publicDependency y)+                                loop+                                  x+                                  mutable'dependency+                                  mutable'enumType+                                  mutable'extension+                                  mutable'messageType+                                  v+                                  mutable'service+                                  mutable'weakDependency+                        82+                          -> do y <- do len <- Data.ProtoLens.Encoding.Bytes.getVarInt+                                        Data.ProtoLens.Encoding.Bytes.isolate+                                          (Prelude.fromIntegral len)+                                          ((let+                                              ploop qs+                                                = do packedEnd <- Data.ProtoLens.Encoding.Bytes.atEnd+                                                     if packedEnd then+                                                         Prelude.return qs+                                                     else+                                                         do !q <- (Data.ProtoLens.Encoding.Bytes.<?>)+                                                                    (Prelude.fmap+                                                                       Prelude.fromIntegral+                                                                       Data.ProtoLens.Encoding.Bytes.getVarInt)+                                                                    "public_dependency"+                                                            qs' <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO+                                                                     (Data.ProtoLens.Encoding.Growing.append+                                                                        qs q)+                                                            ploop qs'+                                            in ploop)+                                             mutable'publicDependency)+                                loop+                                  x+                                  mutable'dependency+                                  mutable'enumType+                                  mutable'extension+                                  mutable'messageType+                                  y+                                  mutable'service+                                  mutable'weakDependency+                        88+                          -> do !y <- (Data.ProtoLens.Encoding.Bytes.<?>)+                                        (Prelude.fmap+                                           Prelude.fromIntegral+                                           Data.ProtoLens.Encoding.Bytes.getVarInt)+                                        "weak_dependency"+                                v <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO+                                       (Data.ProtoLens.Encoding.Growing.append+                                          mutable'weakDependency y)+                                loop+                                  x+                                  mutable'dependency+                                  mutable'enumType+                                  mutable'extension+                                  mutable'messageType+                                  mutable'publicDependency+                                  mutable'service+                                  v+                        90+                          -> do y <- do len <- Data.ProtoLens.Encoding.Bytes.getVarInt+                                        Data.ProtoLens.Encoding.Bytes.isolate+                                          (Prelude.fromIntegral len)+                                          ((let+                                              ploop qs+                                                = do packedEnd <- Data.ProtoLens.Encoding.Bytes.atEnd+                                                     if packedEnd then+                                                         Prelude.return qs+                                                     else+                                                         do !q <- (Data.ProtoLens.Encoding.Bytes.<?>)+                                                                    (Prelude.fmap+                                                                       Prelude.fromIntegral+                                                                       Data.ProtoLens.Encoding.Bytes.getVarInt)+                                                                    "weak_dependency"+                                                            qs' <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO+                                                                     (Data.ProtoLens.Encoding.Growing.append+                                                                        qs q)+                                                            ploop qs'+                                            in ploop)+                                             mutable'weakDependency)+                                loop+                                  x+                                  mutable'dependency+                                  mutable'enumType+                                  mutable'extension+                                  mutable'messageType+                                  mutable'publicDependency+                                  mutable'service+                                  y+                        34+                          -> do !y <- (Data.ProtoLens.Encoding.Bytes.<?>)+                                        (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt+                                            Data.ProtoLens.Encoding.Bytes.isolate+                                              (Prelude.fromIntegral len)+                                              Data.ProtoLens.parseMessage)+                                        "message_type"+                                v <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO+                                       (Data.ProtoLens.Encoding.Growing.append+                                          mutable'messageType y)+                                loop+                                  x+                                  mutable'dependency+                                  mutable'enumType+                                  mutable'extension+                                  v+                                  mutable'publicDependency+                                  mutable'service+                                  mutable'weakDependency+                        42+                          -> do !y <- (Data.ProtoLens.Encoding.Bytes.<?>)+                                        (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt+                                            Data.ProtoLens.Encoding.Bytes.isolate+                                              (Prelude.fromIntegral len)+                                              Data.ProtoLens.parseMessage)+                                        "enum_type"+                                v <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO+                                       (Data.ProtoLens.Encoding.Growing.append mutable'enumType y)+                                loop+                                  x+                                  mutable'dependency+                                  v+                                  mutable'extension+                                  mutable'messageType+                                  mutable'publicDependency+                                  mutable'service+                                  mutable'weakDependency+                        50+                          -> do !y <- (Data.ProtoLens.Encoding.Bytes.<?>)+                                        (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt+                                            Data.ProtoLens.Encoding.Bytes.isolate+                                              (Prelude.fromIntegral len)+                                              Data.ProtoLens.parseMessage)+                                        "service"+                                v <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO+                                       (Data.ProtoLens.Encoding.Growing.append mutable'service y)+                                loop+                                  x+                                  mutable'dependency+                                  mutable'enumType+                                  mutable'extension+                                  mutable'messageType+                                  mutable'publicDependency+                                  v+                                  mutable'weakDependency+                        58+                          -> do !y <- (Data.ProtoLens.Encoding.Bytes.<?>)+                                        (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt+                                            Data.ProtoLens.Encoding.Bytes.isolate+                                              (Prelude.fromIntegral len)+                                              Data.ProtoLens.parseMessage)+                                        "extension"+                                v <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO+                                       (Data.ProtoLens.Encoding.Growing.append mutable'extension y)+                                loop+                                  x+                                  mutable'dependency+                                  mutable'enumType+                                  v+                                  mutable'messageType+                                  mutable'publicDependency+                                  mutable'service+                                  mutable'weakDependency+                        66+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)+                                       (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt+                                           Data.ProtoLens.Encoding.Bytes.isolate+                                             (Prelude.fromIntegral len) Data.ProtoLens.parseMessage)+                                       "options"+                                loop+                                  (Lens.Family2.set (Data.ProtoLens.Field.field @"options") y x)+                                  mutable'dependency+                                  mutable'enumType+                                  mutable'extension+                                  mutable'messageType+                                  mutable'publicDependency+                                  mutable'service+                                  mutable'weakDependency+                        74+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)+                                       (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt+                                           Data.ProtoLens.Encoding.Bytes.isolate+                                             (Prelude.fromIntegral len) Data.ProtoLens.parseMessage)+                                       "source_code_info"+                                loop+                                  (Lens.Family2.set+                                     (Data.ProtoLens.Field.field @"sourceCodeInfo") y x)+                                  mutable'dependency+                                  mutable'enumType+                                  mutable'extension+                                  mutable'messageType+                                  mutable'publicDependency+                                  mutable'service+                                  mutable'weakDependency+                        98+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)+                                       (do value <- do len <- Data.ProtoLens.Encoding.Bytes.getVarInt+                                                       Data.ProtoLens.Encoding.Bytes.getBytes+                                                         (Prelude.fromIntegral len)+                                           Data.ProtoLens.Encoding.Bytes.runEither+                                             (case Data.Text.Encoding.decodeUtf8' value of+                                                (Prelude.Left err)+                                                  -> Prelude.Left (Prelude.show err)+                                                (Prelude.Right r) -> Prelude.Right r))+                                       "syntax"+                                loop+                                  (Lens.Family2.set (Data.ProtoLens.Field.field @"syntax") y x)+                                  mutable'dependency+                                  mutable'enumType+                                  mutable'extension+                                  mutable'messageType+                                  mutable'publicDependency+                                  mutable'service+                                  mutable'weakDependency+                        wire+                          -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire+                                        wire+                                loop+                                  (Lens.Family2.over+                                     Data.ProtoLens.unknownFields (\ !t -> (:) y t) x)+                                  mutable'dependency+                                  mutable'enumType+                                  mutable'extension+                                  mutable'messageType+                                  mutable'publicDependency+                                  mutable'service+                                  mutable'weakDependency+      in+        (Data.ProtoLens.Encoding.Bytes.<?>)+          (do mutable'dependency <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO+                                      Data.ProtoLens.Encoding.Growing.new+              mutable'enumType <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO+                                    Data.ProtoLens.Encoding.Growing.new+              mutable'extension <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO+                                     Data.ProtoLens.Encoding.Growing.new+              mutable'messageType <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO+                                       Data.ProtoLens.Encoding.Growing.new+              mutable'publicDependency <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO+                                            Data.ProtoLens.Encoding.Growing.new+              mutable'service <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO+                                   Data.ProtoLens.Encoding.Growing.new+              mutable'weakDependency <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO+                                          Data.ProtoLens.Encoding.Growing.new+              loop+                Data.ProtoLens.defMessage+                mutable'dependency+                mutable'enumType+                mutable'extension+                mutable'messageType+                mutable'publicDependency+                mutable'service+                mutable'weakDependency)+          "FileDescriptorProto"+  buildMessage+    = \ _x+        -> (Data.Monoid.<>)+             (case+                  Lens.Family2.view (Data.ProtoLens.Field.field @"maybe'name") _x+              of+                Prelude.Nothing -> Data.Monoid.mempty+                (Prelude.Just _v)+                  -> (Data.Monoid.<>)+                       (Data.ProtoLens.Encoding.Bytes.putVarInt 10)+                       ((Prelude..)+                          (\ bs+                             -> (Data.Monoid.<>)+                                  (Data.ProtoLens.Encoding.Bytes.putVarInt+                                     (Prelude.fromIntegral (Data.ByteString.length bs)))+                                  (Data.ProtoLens.Encoding.Bytes.putBytes bs))+                          Data.Text.Encoding.encodeUtf8+                          _v))+             ((Data.Monoid.<>)+                (case+                     Lens.Family2.view (Data.ProtoLens.Field.field @"maybe'package") _x+                 of+                   Prelude.Nothing -> Data.Monoid.mempty+                   (Prelude.Just _v)+                     -> (Data.Monoid.<>)+                          (Data.ProtoLens.Encoding.Bytes.putVarInt 18)+                          ((Prelude..)+                             (\ bs+                                -> (Data.Monoid.<>)+                                     (Data.ProtoLens.Encoding.Bytes.putVarInt+                                        (Prelude.fromIntegral (Data.ByteString.length bs)))+                                     (Data.ProtoLens.Encoding.Bytes.putBytes bs))+                             Data.Text.Encoding.encodeUtf8+                             _v))+                ((Data.Monoid.<>)+                   (Data.ProtoLens.Encoding.Bytes.foldMapBuilder+                      (\ _v+                         -> (Data.Monoid.<>)+                              (Data.ProtoLens.Encoding.Bytes.putVarInt 26)+                              ((Prelude..)+                                 (\ bs+                                    -> (Data.Monoid.<>)+                                         (Data.ProtoLens.Encoding.Bytes.putVarInt+                                            (Prelude.fromIntegral (Data.ByteString.length bs)))+                                         (Data.ProtoLens.Encoding.Bytes.putBytes bs))+                                 Data.Text.Encoding.encodeUtf8+                                 _v))+                      (Lens.Family2.view+                         (Data.ProtoLens.Field.field @"vec'dependency") _x))+                   ((Data.Monoid.<>)+                      (Data.ProtoLens.Encoding.Bytes.foldMapBuilder+                         (\ _v+                            -> (Data.Monoid.<>)+                                 (Data.ProtoLens.Encoding.Bytes.putVarInt 80)+                                 ((Prelude..)+                                    Data.ProtoLens.Encoding.Bytes.putVarInt+                                    Prelude.fromIntegral+                                    _v))+                         (Lens.Family2.view+                            (Data.ProtoLens.Field.field @"vec'publicDependency") _x))+                      ((Data.Monoid.<>)+                         (Data.ProtoLens.Encoding.Bytes.foldMapBuilder+                            (\ _v+                               -> (Data.Monoid.<>)+                                    (Data.ProtoLens.Encoding.Bytes.putVarInt 88)+                                    ((Prelude..)+                                       Data.ProtoLens.Encoding.Bytes.putVarInt+                                       Prelude.fromIntegral+                                       _v))+                            (Lens.Family2.view+                               (Data.ProtoLens.Field.field @"vec'weakDependency") _x))+                         ((Data.Monoid.<>)+                            (Data.ProtoLens.Encoding.Bytes.foldMapBuilder+                               (\ _v+                                  -> (Data.Monoid.<>)+                                       (Data.ProtoLens.Encoding.Bytes.putVarInt 34)+                                       ((Prelude..)+                                          (\ bs+                                             -> (Data.Monoid.<>)+                                                  (Data.ProtoLens.Encoding.Bytes.putVarInt+                                                     (Prelude.fromIntegral+                                                        (Data.ByteString.length bs)))+                                                  (Data.ProtoLens.Encoding.Bytes.putBytes bs))+                                          Data.ProtoLens.encodeMessage+                                          _v))+                               (Lens.Family2.view+                                  (Data.ProtoLens.Field.field @"vec'messageType") _x))+                            ((Data.Monoid.<>)+                               (Data.ProtoLens.Encoding.Bytes.foldMapBuilder+                                  (\ _v+                                     -> (Data.Monoid.<>)+                                          (Data.ProtoLens.Encoding.Bytes.putVarInt 42)+                                          ((Prelude..)+                                             (\ bs+                                                -> (Data.Monoid.<>)+                                                     (Data.ProtoLens.Encoding.Bytes.putVarInt+                                                        (Prelude.fromIntegral+                                                           (Data.ByteString.length bs)))+                                                     (Data.ProtoLens.Encoding.Bytes.putBytes bs))+                                             Data.ProtoLens.encodeMessage+                                             _v))+                                  (Lens.Family2.view+                                     (Data.ProtoLens.Field.field @"vec'enumType") _x))+                               ((Data.Monoid.<>)+                                  (Data.ProtoLens.Encoding.Bytes.foldMapBuilder+                                     (\ _v+                                        -> (Data.Monoid.<>)+                                             (Data.ProtoLens.Encoding.Bytes.putVarInt 50)+                                             ((Prelude..)+                                                (\ bs+                                                   -> (Data.Monoid.<>)+                                                        (Data.ProtoLens.Encoding.Bytes.putVarInt+                                                           (Prelude.fromIntegral+                                                              (Data.ByteString.length bs)))+                                                        (Data.ProtoLens.Encoding.Bytes.putBytes bs))+                                                Data.ProtoLens.encodeMessage+                                                _v))+                                     (Lens.Family2.view+                                        (Data.ProtoLens.Field.field @"vec'service") _x))+                                  ((Data.Monoid.<>)+                                     (Data.ProtoLens.Encoding.Bytes.foldMapBuilder+                                        (\ _v+                                           -> (Data.Monoid.<>)+                                                (Data.ProtoLens.Encoding.Bytes.putVarInt 58)+                                                ((Prelude..)+                                                   (\ bs+                                                      -> (Data.Monoid.<>)+                                                           (Data.ProtoLens.Encoding.Bytes.putVarInt+                                                              (Prelude.fromIntegral+                                                                 (Data.ByteString.length bs)))+                                                           (Data.ProtoLens.Encoding.Bytes.putBytes+                                                              bs))+                                                   Data.ProtoLens.encodeMessage+                                                   _v))+                                        (Lens.Family2.view+                                           (Data.ProtoLens.Field.field @"vec'extension") _x))+                                     ((Data.Monoid.<>)+                                        (case+                                             Lens.Family2.view+                                               (Data.ProtoLens.Field.field @"maybe'options") _x+                                         of+                                           Prelude.Nothing -> Data.Monoid.mempty+                                           (Prelude.Just _v)+                                             -> (Data.Monoid.<>)+                                                  (Data.ProtoLens.Encoding.Bytes.putVarInt 66)+                                                  ((Prelude..)+                                                     (\ bs+                                                        -> (Data.Monoid.<>)+                                                             (Data.ProtoLens.Encoding.Bytes.putVarInt+                                                                (Prelude.fromIntegral+                                                                   (Data.ByteString.length bs)))+                                                             (Data.ProtoLens.Encoding.Bytes.putBytes+                                                                bs))+                                                     Data.ProtoLens.encodeMessage+                                                     _v))+                                        ((Data.Monoid.<>)+                                           (case+                                                Lens.Family2.view+                                                  (Data.ProtoLens.Field.field+                                                     @"maybe'sourceCodeInfo")+                                                  _x+                                            of+                                              Prelude.Nothing -> Data.Monoid.mempty+                                              (Prelude.Just _v)+                                                -> (Data.Monoid.<>)+                                                     (Data.ProtoLens.Encoding.Bytes.putVarInt 74)+                                                     ((Prelude..)+                                                        (\ bs+                                                           -> (Data.Monoid.<>)+                                                                (Data.ProtoLens.Encoding.Bytes.putVarInt+                                                                   (Prelude.fromIntegral+                                                                      (Data.ByteString.length bs)))+                                                                (Data.ProtoLens.Encoding.Bytes.putBytes+                                                                   bs))+                                                        Data.ProtoLens.encodeMessage+                                                        _v))+                                           ((Data.Monoid.<>)+                                              (case+                                                   Lens.Family2.view+                                                     (Data.ProtoLens.Field.field @"maybe'syntax") _x+                                               of+                                                 Prelude.Nothing -> Data.Monoid.mempty+                                                 (Prelude.Just _v)+                                                   -> (Data.Monoid.<>)+                                                        (Data.ProtoLens.Encoding.Bytes.putVarInt 98)+                                                        ((Prelude..)+                                                           (\ bs+                                                              -> (Data.Monoid.<>)+                                                                   (Data.ProtoLens.Encoding.Bytes.putVarInt+                                                                      (Prelude.fromIntegral+                                                                         (Data.ByteString.length+                                                                            bs)))+                                                                   (Data.ProtoLens.Encoding.Bytes.putBytes+                                                                      bs))+                                                           Data.Text.Encoding.encodeUtf8+                                                           _v))+                                              (Data.ProtoLens.Encoding.Wire.buildFieldSet+                                                 (Lens.Family2.view+                                                    Data.ProtoLens.unknownFields _x)))))))))))))+instance Control.DeepSeq.NFData FileDescriptorProto where+  rnf+    = \ x__+        -> Control.DeepSeq.deepseq+             (_FileDescriptorProto'_unknownFields x__)+             (Control.DeepSeq.deepseq+                (_FileDescriptorProto'name x__)+                (Control.DeepSeq.deepseq+                   (_FileDescriptorProto'package x__)+                   (Control.DeepSeq.deepseq+                      (_FileDescriptorProto'dependency x__)+                      (Control.DeepSeq.deepseq+                         (_FileDescriptorProto'publicDependency x__)+                         (Control.DeepSeq.deepseq+                            (_FileDescriptorProto'weakDependency x__)+                            (Control.DeepSeq.deepseq+                               (_FileDescriptorProto'messageType x__)+                               (Control.DeepSeq.deepseq+                                  (_FileDescriptorProto'enumType x__)+                                  (Control.DeepSeq.deepseq+                                     (_FileDescriptorProto'service x__)+                                     (Control.DeepSeq.deepseq+                                        (_FileDescriptorProto'extension x__)+                                        (Control.DeepSeq.deepseq+                                           (_FileDescriptorProto'options x__)+                                           (Control.DeepSeq.deepseq+                                              (_FileDescriptorProto'sourceCodeInfo x__)+                                              (Control.DeepSeq.deepseq+                                                 (_FileDescriptorProto'syntax x__) ()))))))))))))+{- | Fields :+     +         * 'Proto.Google.Protobuf.Descriptor_Fields.file' @:: Lens' FileDescriptorSet [FileDescriptorProto]@+         * 'Proto.Google.Protobuf.Descriptor_Fields.vec'file' @:: Lens' FileDescriptorSet (Data.Vector.Vector FileDescriptorProto)@ -}+data FileDescriptorSet+  = FileDescriptorSet'_constructor {_FileDescriptorSet'file :: !(Data.Vector.Vector FileDescriptorProto),+                                    _FileDescriptorSet'_unknownFields :: !Data.ProtoLens.FieldSet}+  deriving (Prelude.Eq, Prelude.Ord)+instance Prelude.Show FileDescriptorSet where+  showsPrec _ __x __s+    = Prelude.showChar+        '{'+        (Prelude.showString+           (Data.ProtoLens.showMessageShort __x) (Prelude.showChar '}' __s))+instance Data.ProtoLens.Field.HasField FileDescriptorSet "file" [FileDescriptorProto] where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _FileDescriptorSet'file+           (\ x__ y__ -> x__ {_FileDescriptorSet'file = y__}))+        (Lens.Family2.Unchecked.lens+           Data.Vector.Generic.toList+           (\ _ y__ -> Data.Vector.Generic.fromList y__))+instance Data.ProtoLens.Field.HasField FileDescriptorSet "vec'file" (Data.Vector.Vector FileDescriptorProto) where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _FileDescriptorSet'file+           (\ x__ y__ -> x__ {_FileDescriptorSet'file = y__}))+        Prelude.id+instance Data.ProtoLens.Message FileDescriptorSet where+  messageName _ = Data.Text.pack "google.protobuf.FileDescriptorSet"+  fieldsByTag+    = let+        file__field_descriptor+          = Data.ProtoLens.FieldDescriptor+              "file"+              (Data.ProtoLens.MessageField Data.ProtoLens.MessageType ::+                 Data.ProtoLens.FieldTypeDescriptor FileDescriptorProto)+              (Data.ProtoLens.RepeatedField+                 Data.ProtoLens.Unpacked (Data.ProtoLens.Field.field @"file")) ::+              Data.ProtoLens.FieldDescriptor FileDescriptorSet+      in+        Data.Map.fromList [(Data.ProtoLens.Tag 1, file__field_descriptor)]+  unknownFields+    = Lens.Family2.Unchecked.lens+        _FileDescriptorSet'_unknownFields+        (\ x__ y__ -> x__ {_FileDescriptorSet'_unknownFields = y__})+  defMessage+    = FileDescriptorSet'_constructor+        {_FileDescriptorSet'file = Data.Vector.Generic.empty,+         _FileDescriptorSet'_unknownFields = []}+  parseMessage+    = let+        loop ::+          FileDescriptorSet+          -> Data.ProtoLens.Encoding.Growing.Growing Data.Vector.Vector Data.ProtoLens.Encoding.Growing.RealWorld FileDescriptorProto+             -> Data.ProtoLens.Encoding.Bytes.Parser FileDescriptorSet+        loop x mutable'file+          = do end <- Data.ProtoLens.Encoding.Bytes.atEnd+               if end then+                   do frozen'file <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO+                                       (Data.ProtoLens.Encoding.Growing.unsafeFreeze mutable'file)+                      (let missing = []+                       in+                         if Prelude.null missing then+                             Prelude.return ()+                         else+                             Prelude.fail+                               ((Prelude.++)+                                  "Missing required fields: "+                                  (Prelude.show (missing :: [Prelude.String]))))+                      Prelude.return+                        (Lens.Family2.over+                           Data.ProtoLens.unknownFields+                           (\ !t -> Prelude.reverse t)+                           (Lens.Family2.set+                              (Data.ProtoLens.Field.field @"vec'file") frozen'file x))+               else+                   do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt+                      case tag of+                        10+                          -> do !y <- (Data.ProtoLens.Encoding.Bytes.<?>)+                                        (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt+                                            Data.ProtoLens.Encoding.Bytes.isolate+                                              (Prelude.fromIntegral len)+                                              Data.ProtoLens.parseMessage)+                                        "file"+                                v <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO+                                       (Data.ProtoLens.Encoding.Growing.append mutable'file y)+                                loop x v+                        wire+                          -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire+                                        wire+                                loop+                                  (Lens.Family2.over+                                     Data.ProtoLens.unknownFields (\ !t -> (:) y t) x)+                                  mutable'file+      in+        (Data.ProtoLens.Encoding.Bytes.<?>)+          (do mutable'file <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO+                                Data.ProtoLens.Encoding.Growing.new+              loop Data.ProtoLens.defMessage mutable'file)+          "FileDescriptorSet"+  buildMessage+    = \ _x+        -> (Data.Monoid.<>)+             (Data.ProtoLens.Encoding.Bytes.foldMapBuilder+                (\ _v+                   -> (Data.Monoid.<>)+                        (Data.ProtoLens.Encoding.Bytes.putVarInt 10)+                        ((Prelude..)+                           (\ bs+                              -> (Data.Monoid.<>)+                                   (Data.ProtoLens.Encoding.Bytes.putVarInt+                                      (Prelude.fromIntegral (Data.ByteString.length bs)))+                                   (Data.ProtoLens.Encoding.Bytes.putBytes bs))+                           Data.ProtoLens.encodeMessage+                           _v))+                (Lens.Family2.view (Data.ProtoLens.Field.field @"vec'file") _x))+             (Data.ProtoLens.Encoding.Wire.buildFieldSet+                (Lens.Family2.view Data.ProtoLens.unknownFields _x))+instance Control.DeepSeq.NFData FileDescriptorSet where+  rnf+    = \ x__+        -> Control.DeepSeq.deepseq+             (_FileDescriptorSet'_unknownFields x__)+             (Control.DeepSeq.deepseq (_FileDescriptorSet'file x__) ())+{- | Fields :+     +         * 'Proto.Google.Protobuf.Descriptor_Fields.javaPackage' @:: Lens' FileOptions Data.Text.Text@+         * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'javaPackage' @:: Lens' FileOptions (Prelude.Maybe Data.Text.Text)@+         * 'Proto.Google.Protobuf.Descriptor_Fields.javaOuterClassname' @:: Lens' FileOptions Data.Text.Text@+         * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'javaOuterClassname' @:: Lens' FileOptions (Prelude.Maybe Data.Text.Text)@+         * 'Proto.Google.Protobuf.Descriptor_Fields.javaMultipleFiles' @:: Lens' FileOptions Prelude.Bool@+         * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'javaMultipleFiles' @:: Lens' FileOptions (Prelude.Maybe Prelude.Bool)@+         * 'Proto.Google.Protobuf.Descriptor_Fields.javaGenerateEqualsAndHash' @:: Lens' FileOptions Prelude.Bool@+         * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'javaGenerateEqualsAndHash' @:: Lens' FileOptions (Prelude.Maybe Prelude.Bool)@+         * 'Proto.Google.Protobuf.Descriptor_Fields.javaStringCheckUtf8' @:: Lens' FileOptions Prelude.Bool@+         * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'javaStringCheckUtf8' @:: Lens' FileOptions (Prelude.Maybe Prelude.Bool)@+         * 'Proto.Google.Protobuf.Descriptor_Fields.optimizeFor' @:: Lens' FileOptions FileOptions'OptimizeMode@+         * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'optimizeFor' @:: Lens' FileOptions (Prelude.Maybe FileOptions'OptimizeMode)@+         * 'Proto.Google.Protobuf.Descriptor_Fields.goPackage' @:: Lens' FileOptions Data.Text.Text@+         * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'goPackage' @:: Lens' FileOptions (Prelude.Maybe Data.Text.Text)@+         * 'Proto.Google.Protobuf.Descriptor_Fields.ccGenericServices' @:: Lens' FileOptions Prelude.Bool@+         * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'ccGenericServices' @:: Lens' FileOptions (Prelude.Maybe Prelude.Bool)@+         * 'Proto.Google.Protobuf.Descriptor_Fields.javaGenericServices' @:: Lens' FileOptions Prelude.Bool@+         * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'javaGenericServices' @:: Lens' FileOptions (Prelude.Maybe Prelude.Bool)@+         * 'Proto.Google.Protobuf.Descriptor_Fields.pyGenericServices' @:: Lens' FileOptions Prelude.Bool@+         * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'pyGenericServices' @:: Lens' FileOptions (Prelude.Maybe Prelude.Bool)@+         * 'Proto.Google.Protobuf.Descriptor_Fields.phpGenericServices' @:: Lens' FileOptions Prelude.Bool@+         * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'phpGenericServices' @:: Lens' FileOptions (Prelude.Maybe Prelude.Bool)@+         * 'Proto.Google.Protobuf.Descriptor_Fields.deprecated' @:: Lens' FileOptions Prelude.Bool@+         * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'deprecated' @:: Lens' FileOptions (Prelude.Maybe Prelude.Bool)@+         * 'Proto.Google.Protobuf.Descriptor_Fields.ccEnableArenas' @:: Lens' FileOptions Prelude.Bool@+         * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'ccEnableArenas' @:: Lens' FileOptions (Prelude.Maybe Prelude.Bool)@+         * 'Proto.Google.Protobuf.Descriptor_Fields.objcClassPrefix' @:: Lens' FileOptions Data.Text.Text@+         * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'objcClassPrefix' @:: Lens' FileOptions (Prelude.Maybe Data.Text.Text)@+         * 'Proto.Google.Protobuf.Descriptor_Fields.csharpNamespace' @:: Lens' FileOptions Data.Text.Text@+         * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'csharpNamespace' @:: Lens' FileOptions (Prelude.Maybe Data.Text.Text)@+         * 'Proto.Google.Protobuf.Descriptor_Fields.swiftPrefix' @:: Lens' FileOptions Data.Text.Text@+         * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'swiftPrefix' @:: Lens' FileOptions (Prelude.Maybe Data.Text.Text)@+         * 'Proto.Google.Protobuf.Descriptor_Fields.phpClassPrefix' @:: Lens' FileOptions Data.Text.Text@+         * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'phpClassPrefix' @:: Lens' FileOptions (Prelude.Maybe Data.Text.Text)@+         * 'Proto.Google.Protobuf.Descriptor_Fields.phpNamespace' @:: Lens' FileOptions Data.Text.Text@+         * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'phpNamespace' @:: Lens' FileOptions (Prelude.Maybe Data.Text.Text)@+         * 'Proto.Google.Protobuf.Descriptor_Fields.phpMetadataNamespace' @:: Lens' FileOptions Data.Text.Text@+         * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'phpMetadataNamespace' @:: Lens' FileOptions (Prelude.Maybe Data.Text.Text)@+         * 'Proto.Google.Protobuf.Descriptor_Fields.rubyPackage' @:: Lens' FileOptions Data.Text.Text@+         * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'rubyPackage' @:: Lens' FileOptions (Prelude.Maybe Data.Text.Text)@+         * 'Proto.Google.Protobuf.Descriptor_Fields.uninterpretedOption' @:: Lens' FileOptions [UninterpretedOption]@+         * 'Proto.Google.Protobuf.Descriptor_Fields.vec'uninterpretedOption' @:: Lens' FileOptions (Data.Vector.Vector UninterpretedOption)@ -}+data FileOptions+  = FileOptions'_constructor {_FileOptions'javaPackage :: !(Prelude.Maybe Data.Text.Text),+                              _FileOptions'javaOuterClassname :: !(Prelude.Maybe Data.Text.Text),+                              _FileOptions'javaMultipleFiles :: !(Prelude.Maybe Prelude.Bool),+                              _FileOptions'javaGenerateEqualsAndHash :: !(Prelude.Maybe Prelude.Bool),+                              _FileOptions'javaStringCheckUtf8 :: !(Prelude.Maybe Prelude.Bool),+                              _FileOptions'optimizeFor :: !(Prelude.Maybe FileOptions'OptimizeMode),+                              _FileOptions'goPackage :: !(Prelude.Maybe Data.Text.Text),+                              _FileOptions'ccGenericServices :: !(Prelude.Maybe Prelude.Bool),+                              _FileOptions'javaGenericServices :: !(Prelude.Maybe Prelude.Bool),+                              _FileOptions'pyGenericServices :: !(Prelude.Maybe Prelude.Bool),+                              _FileOptions'phpGenericServices :: !(Prelude.Maybe Prelude.Bool),+                              _FileOptions'deprecated :: !(Prelude.Maybe Prelude.Bool),+                              _FileOptions'ccEnableArenas :: !(Prelude.Maybe Prelude.Bool),+                              _FileOptions'objcClassPrefix :: !(Prelude.Maybe Data.Text.Text),+                              _FileOptions'csharpNamespace :: !(Prelude.Maybe Data.Text.Text),+                              _FileOptions'swiftPrefix :: !(Prelude.Maybe Data.Text.Text),+                              _FileOptions'phpClassPrefix :: !(Prelude.Maybe Data.Text.Text),+                              _FileOptions'phpNamespace :: !(Prelude.Maybe Data.Text.Text),+                              _FileOptions'phpMetadataNamespace :: !(Prelude.Maybe Data.Text.Text),+                              _FileOptions'rubyPackage :: !(Prelude.Maybe Data.Text.Text),+                              _FileOptions'uninterpretedOption :: !(Data.Vector.Vector UninterpretedOption),+                              _FileOptions'_unknownFields :: !Data.ProtoLens.FieldSet}+  deriving (Prelude.Eq, Prelude.Ord)+instance Prelude.Show FileOptions where+  showsPrec _ __x __s+    = Prelude.showChar+        '{'+        (Prelude.showString+           (Data.ProtoLens.showMessageShort __x) (Prelude.showChar '}' __s))+instance Data.ProtoLens.Field.HasField FileOptions "javaPackage" Data.Text.Text where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _FileOptions'javaPackage+           (\ x__ y__ -> x__ {_FileOptions'javaPackage = y__}))+        (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault)+instance Data.ProtoLens.Field.HasField FileOptions "maybe'javaPackage" (Prelude.Maybe Data.Text.Text) where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _FileOptions'javaPackage+           (\ x__ y__ -> x__ {_FileOptions'javaPackage = y__}))+        Prelude.id+instance Data.ProtoLens.Field.HasField FileOptions "javaOuterClassname" Data.Text.Text where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _FileOptions'javaOuterClassname+           (\ x__ y__ -> x__ {_FileOptions'javaOuterClassname = y__}))+        (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault)+instance Data.ProtoLens.Field.HasField FileOptions "maybe'javaOuterClassname" (Prelude.Maybe Data.Text.Text) where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _FileOptions'javaOuterClassname+           (\ x__ y__ -> x__ {_FileOptions'javaOuterClassname = y__}))+        Prelude.id+instance Data.ProtoLens.Field.HasField FileOptions "javaMultipleFiles" Prelude.Bool where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _FileOptions'javaMultipleFiles+           (\ x__ y__ -> x__ {_FileOptions'javaMultipleFiles = y__}))+        (Data.ProtoLens.maybeLens Prelude.False)+instance Data.ProtoLens.Field.HasField FileOptions "maybe'javaMultipleFiles" (Prelude.Maybe Prelude.Bool) where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _FileOptions'javaMultipleFiles+           (\ x__ y__ -> x__ {_FileOptions'javaMultipleFiles = y__}))+        Prelude.id+instance Data.ProtoLens.Field.HasField FileOptions "javaGenerateEqualsAndHash" Prelude.Bool where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _FileOptions'javaGenerateEqualsAndHash+           (\ x__ y__ -> x__ {_FileOptions'javaGenerateEqualsAndHash = y__}))+        (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault)+instance Data.ProtoLens.Field.HasField FileOptions "maybe'javaGenerateEqualsAndHash" (Prelude.Maybe Prelude.Bool) where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _FileOptions'javaGenerateEqualsAndHash+           (\ x__ y__ -> x__ {_FileOptions'javaGenerateEqualsAndHash = y__}))+        Prelude.id+instance Data.ProtoLens.Field.HasField FileOptions "javaStringCheckUtf8" Prelude.Bool where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _FileOptions'javaStringCheckUtf8+           (\ x__ y__ -> x__ {_FileOptions'javaStringCheckUtf8 = y__}))+        (Data.ProtoLens.maybeLens Prelude.False)+instance Data.ProtoLens.Field.HasField FileOptions "maybe'javaStringCheckUtf8" (Prelude.Maybe Prelude.Bool) where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _FileOptions'javaStringCheckUtf8+           (\ x__ y__ -> x__ {_FileOptions'javaStringCheckUtf8 = y__}))+        Prelude.id+instance Data.ProtoLens.Field.HasField FileOptions "optimizeFor" FileOptions'OptimizeMode where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _FileOptions'optimizeFor+           (\ x__ y__ -> x__ {_FileOptions'optimizeFor = y__}))+        (Data.ProtoLens.maybeLens FileOptions'SPEED)+instance Data.ProtoLens.Field.HasField FileOptions "maybe'optimizeFor" (Prelude.Maybe FileOptions'OptimizeMode) where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _FileOptions'optimizeFor+           (\ x__ y__ -> x__ {_FileOptions'optimizeFor = y__}))+        Prelude.id+instance Data.ProtoLens.Field.HasField FileOptions "goPackage" Data.Text.Text where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _FileOptions'goPackage+           (\ x__ y__ -> x__ {_FileOptions'goPackage = y__}))+        (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault)+instance Data.ProtoLens.Field.HasField FileOptions "maybe'goPackage" (Prelude.Maybe Data.Text.Text) where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _FileOptions'goPackage+           (\ x__ y__ -> x__ {_FileOptions'goPackage = y__}))+        Prelude.id+instance Data.ProtoLens.Field.HasField FileOptions "ccGenericServices" Prelude.Bool where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _FileOptions'ccGenericServices+           (\ x__ y__ -> x__ {_FileOptions'ccGenericServices = y__}))+        (Data.ProtoLens.maybeLens Prelude.False)+instance Data.ProtoLens.Field.HasField FileOptions "maybe'ccGenericServices" (Prelude.Maybe Prelude.Bool) where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _FileOptions'ccGenericServices+           (\ x__ y__ -> x__ {_FileOptions'ccGenericServices = y__}))+        Prelude.id+instance Data.ProtoLens.Field.HasField FileOptions "javaGenericServices" Prelude.Bool where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _FileOptions'javaGenericServices+           (\ x__ y__ -> x__ {_FileOptions'javaGenericServices = y__}))+        (Data.ProtoLens.maybeLens Prelude.False)+instance Data.ProtoLens.Field.HasField FileOptions "maybe'javaGenericServices" (Prelude.Maybe Prelude.Bool) where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _FileOptions'javaGenericServices+           (\ x__ y__ -> x__ {_FileOptions'javaGenericServices = y__}))+        Prelude.id+instance Data.ProtoLens.Field.HasField FileOptions "pyGenericServices" Prelude.Bool where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _FileOptions'pyGenericServices+           (\ x__ y__ -> x__ {_FileOptions'pyGenericServices = y__}))+        (Data.ProtoLens.maybeLens Prelude.False)+instance Data.ProtoLens.Field.HasField FileOptions "maybe'pyGenericServices" (Prelude.Maybe Prelude.Bool) where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _FileOptions'pyGenericServices+           (\ x__ y__ -> x__ {_FileOptions'pyGenericServices = y__}))+        Prelude.id+instance Data.ProtoLens.Field.HasField FileOptions "phpGenericServices" Prelude.Bool where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _FileOptions'phpGenericServices+           (\ x__ y__ -> x__ {_FileOptions'phpGenericServices = y__}))+        (Data.ProtoLens.maybeLens Prelude.False)+instance Data.ProtoLens.Field.HasField FileOptions "maybe'phpGenericServices" (Prelude.Maybe Prelude.Bool) where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _FileOptions'phpGenericServices+           (\ x__ y__ -> x__ {_FileOptions'phpGenericServices = y__}))+        Prelude.id+instance Data.ProtoLens.Field.HasField FileOptions "deprecated" Prelude.Bool where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _FileOptions'deprecated+           (\ x__ y__ -> x__ {_FileOptions'deprecated = y__}))+        (Data.ProtoLens.maybeLens Prelude.False)+instance Data.ProtoLens.Field.HasField FileOptions "maybe'deprecated" (Prelude.Maybe Prelude.Bool) where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _FileOptions'deprecated+           (\ x__ y__ -> x__ {_FileOptions'deprecated = y__}))+        Prelude.id+instance Data.ProtoLens.Field.HasField FileOptions "ccEnableArenas" Prelude.Bool where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _FileOptions'ccEnableArenas+           (\ x__ y__ -> x__ {_FileOptions'ccEnableArenas = y__}))+        (Data.ProtoLens.maybeLens Prelude.False)+instance Data.ProtoLens.Field.HasField FileOptions "maybe'ccEnableArenas" (Prelude.Maybe Prelude.Bool) where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _FileOptions'ccEnableArenas+           (\ x__ y__ -> x__ {_FileOptions'ccEnableArenas = y__}))+        Prelude.id+instance Data.ProtoLens.Field.HasField FileOptions "objcClassPrefix" Data.Text.Text where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _FileOptions'objcClassPrefix+           (\ x__ y__ -> x__ {_FileOptions'objcClassPrefix = y__}))+        (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault)+instance Data.ProtoLens.Field.HasField FileOptions "maybe'objcClassPrefix" (Prelude.Maybe Data.Text.Text) where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _FileOptions'objcClassPrefix+           (\ x__ y__ -> x__ {_FileOptions'objcClassPrefix = y__}))+        Prelude.id+instance Data.ProtoLens.Field.HasField FileOptions "csharpNamespace" Data.Text.Text where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _FileOptions'csharpNamespace+           (\ x__ y__ -> x__ {_FileOptions'csharpNamespace = y__}))+        (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault)+instance Data.ProtoLens.Field.HasField FileOptions "maybe'csharpNamespace" (Prelude.Maybe Data.Text.Text) where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _FileOptions'csharpNamespace+           (\ x__ y__ -> x__ {_FileOptions'csharpNamespace = y__}))+        Prelude.id+instance Data.ProtoLens.Field.HasField FileOptions "swiftPrefix" Data.Text.Text where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _FileOptions'swiftPrefix+           (\ x__ y__ -> x__ {_FileOptions'swiftPrefix = y__}))+        (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault)+instance Data.ProtoLens.Field.HasField FileOptions "maybe'swiftPrefix" (Prelude.Maybe Data.Text.Text) where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _FileOptions'swiftPrefix+           (\ x__ y__ -> x__ {_FileOptions'swiftPrefix = y__}))+        Prelude.id+instance Data.ProtoLens.Field.HasField FileOptions "phpClassPrefix" Data.Text.Text where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _FileOptions'phpClassPrefix+           (\ x__ y__ -> x__ {_FileOptions'phpClassPrefix = y__}))+        (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault)+instance Data.ProtoLens.Field.HasField FileOptions "maybe'phpClassPrefix" (Prelude.Maybe Data.Text.Text) where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _FileOptions'phpClassPrefix+           (\ x__ y__ -> x__ {_FileOptions'phpClassPrefix = y__}))+        Prelude.id+instance Data.ProtoLens.Field.HasField FileOptions "phpNamespace" Data.Text.Text where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _FileOptions'phpNamespace+           (\ x__ y__ -> x__ {_FileOptions'phpNamespace = y__}))+        (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault)+instance Data.ProtoLens.Field.HasField FileOptions "maybe'phpNamespace" (Prelude.Maybe Data.Text.Text) where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _FileOptions'phpNamespace+           (\ x__ y__ -> x__ {_FileOptions'phpNamespace = y__}))+        Prelude.id+instance Data.ProtoLens.Field.HasField FileOptions "phpMetadataNamespace" Data.Text.Text where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _FileOptions'phpMetadataNamespace+           (\ x__ y__ -> x__ {_FileOptions'phpMetadataNamespace = y__}))+        (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault)+instance Data.ProtoLens.Field.HasField FileOptions "maybe'phpMetadataNamespace" (Prelude.Maybe Data.Text.Text) where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _FileOptions'phpMetadataNamespace+           (\ x__ y__ -> x__ {_FileOptions'phpMetadataNamespace = y__}))+        Prelude.id+instance Data.ProtoLens.Field.HasField FileOptions "rubyPackage" Data.Text.Text where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _FileOptions'rubyPackage+           (\ x__ y__ -> x__ {_FileOptions'rubyPackage = y__}))+        (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault)+instance Data.ProtoLens.Field.HasField FileOptions "maybe'rubyPackage" (Prelude.Maybe Data.Text.Text) where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _FileOptions'rubyPackage+           (\ x__ y__ -> x__ {_FileOptions'rubyPackage = y__}))+        Prelude.id+instance Data.ProtoLens.Field.HasField FileOptions "uninterpretedOption" [UninterpretedOption] where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _FileOptions'uninterpretedOption+           (\ x__ y__ -> x__ {_FileOptions'uninterpretedOption = y__}))+        (Lens.Family2.Unchecked.lens+           Data.Vector.Generic.toList+           (\ _ y__ -> Data.Vector.Generic.fromList y__))+instance Data.ProtoLens.Field.HasField FileOptions "vec'uninterpretedOption" (Data.Vector.Vector UninterpretedOption) where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _FileOptions'uninterpretedOption+           (\ x__ y__ -> x__ {_FileOptions'uninterpretedOption = y__}))+        Prelude.id+instance Data.ProtoLens.Message FileOptions where+  messageName _ = Data.Text.pack "google.protobuf.FileOptions"+  fieldsByTag+    = let+        javaPackage__field_descriptor+          = Data.ProtoLens.FieldDescriptor+              "java_package"+              (Data.ProtoLens.ScalarField Data.ProtoLens.StringField ::+                 Data.ProtoLens.FieldTypeDescriptor Data.Text.Text)+              (Data.ProtoLens.OptionalField+                 (Data.ProtoLens.Field.field @"maybe'javaPackage")) ::+              Data.ProtoLens.FieldDescriptor FileOptions+        javaOuterClassname__field_descriptor+          = Data.ProtoLens.FieldDescriptor+              "java_outer_classname"+              (Data.ProtoLens.ScalarField Data.ProtoLens.StringField ::+                 Data.ProtoLens.FieldTypeDescriptor Data.Text.Text)+              (Data.ProtoLens.OptionalField+                 (Data.ProtoLens.Field.field @"maybe'javaOuterClassname")) ::+              Data.ProtoLens.FieldDescriptor FileOptions+        javaMultipleFiles__field_descriptor+          = Data.ProtoLens.FieldDescriptor+              "java_multiple_files"+              (Data.ProtoLens.ScalarField Data.ProtoLens.BoolField ::+                 Data.ProtoLens.FieldTypeDescriptor Prelude.Bool)+              (Data.ProtoLens.OptionalField+                 (Data.ProtoLens.Field.field @"maybe'javaMultipleFiles")) ::+              Data.ProtoLens.FieldDescriptor FileOptions+        javaGenerateEqualsAndHash__field_descriptor+          = Data.ProtoLens.FieldDescriptor+              "java_generate_equals_and_hash"+              (Data.ProtoLens.ScalarField Data.ProtoLens.BoolField ::+                 Data.ProtoLens.FieldTypeDescriptor Prelude.Bool)+              (Data.ProtoLens.OptionalField+                 (Data.ProtoLens.Field.field @"maybe'javaGenerateEqualsAndHash")) ::+              Data.ProtoLens.FieldDescriptor FileOptions+        javaStringCheckUtf8__field_descriptor+          = Data.ProtoLens.FieldDescriptor+              "java_string_check_utf8"+              (Data.ProtoLens.ScalarField Data.ProtoLens.BoolField ::+                 Data.ProtoLens.FieldTypeDescriptor Prelude.Bool)+              (Data.ProtoLens.OptionalField+                 (Data.ProtoLens.Field.field @"maybe'javaStringCheckUtf8")) ::+              Data.ProtoLens.FieldDescriptor FileOptions+        optimizeFor__field_descriptor+          = Data.ProtoLens.FieldDescriptor+              "optimize_for"+              (Data.ProtoLens.ScalarField Data.ProtoLens.EnumField ::+                 Data.ProtoLens.FieldTypeDescriptor FileOptions'OptimizeMode)+              (Data.ProtoLens.OptionalField+                 (Data.ProtoLens.Field.field @"maybe'optimizeFor")) ::+              Data.ProtoLens.FieldDescriptor FileOptions+        goPackage__field_descriptor+          = Data.ProtoLens.FieldDescriptor+              "go_package"+              (Data.ProtoLens.ScalarField Data.ProtoLens.StringField ::+                 Data.ProtoLens.FieldTypeDescriptor Data.Text.Text)+              (Data.ProtoLens.OptionalField+                 (Data.ProtoLens.Field.field @"maybe'goPackage")) ::+              Data.ProtoLens.FieldDescriptor FileOptions+        ccGenericServices__field_descriptor+          = Data.ProtoLens.FieldDescriptor+              "cc_generic_services"+              (Data.ProtoLens.ScalarField Data.ProtoLens.BoolField ::+                 Data.ProtoLens.FieldTypeDescriptor Prelude.Bool)+              (Data.ProtoLens.OptionalField+                 (Data.ProtoLens.Field.field @"maybe'ccGenericServices")) ::+              Data.ProtoLens.FieldDescriptor FileOptions+        javaGenericServices__field_descriptor+          = Data.ProtoLens.FieldDescriptor+              "java_generic_services"+              (Data.ProtoLens.ScalarField Data.ProtoLens.BoolField ::+                 Data.ProtoLens.FieldTypeDescriptor Prelude.Bool)+              (Data.ProtoLens.OptionalField+                 (Data.ProtoLens.Field.field @"maybe'javaGenericServices")) ::+              Data.ProtoLens.FieldDescriptor FileOptions+        pyGenericServices__field_descriptor+          = Data.ProtoLens.FieldDescriptor+              "py_generic_services"+              (Data.ProtoLens.ScalarField Data.ProtoLens.BoolField ::+                 Data.ProtoLens.FieldTypeDescriptor Prelude.Bool)+              (Data.ProtoLens.OptionalField+                 (Data.ProtoLens.Field.field @"maybe'pyGenericServices")) ::+              Data.ProtoLens.FieldDescriptor FileOptions+        phpGenericServices__field_descriptor+          = Data.ProtoLens.FieldDescriptor+              "php_generic_services"+              (Data.ProtoLens.ScalarField Data.ProtoLens.BoolField ::+                 Data.ProtoLens.FieldTypeDescriptor Prelude.Bool)+              (Data.ProtoLens.OptionalField+                 (Data.ProtoLens.Field.field @"maybe'phpGenericServices")) ::+              Data.ProtoLens.FieldDescriptor FileOptions+        deprecated__field_descriptor+          = Data.ProtoLens.FieldDescriptor+              "deprecated"+              (Data.ProtoLens.ScalarField Data.ProtoLens.BoolField ::+                 Data.ProtoLens.FieldTypeDescriptor Prelude.Bool)+              (Data.ProtoLens.OptionalField+                 (Data.ProtoLens.Field.field @"maybe'deprecated")) ::+              Data.ProtoLens.FieldDescriptor FileOptions+        ccEnableArenas__field_descriptor+          = Data.ProtoLens.FieldDescriptor+              "cc_enable_arenas"+              (Data.ProtoLens.ScalarField Data.ProtoLens.BoolField ::+                 Data.ProtoLens.FieldTypeDescriptor Prelude.Bool)+              (Data.ProtoLens.OptionalField+                 (Data.ProtoLens.Field.field @"maybe'ccEnableArenas")) ::+              Data.ProtoLens.FieldDescriptor FileOptions+        objcClassPrefix__field_descriptor+          = Data.ProtoLens.FieldDescriptor+              "objc_class_prefix"+              (Data.ProtoLens.ScalarField Data.ProtoLens.StringField ::+                 Data.ProtoLens.FieldTypeDescriptor Data.Text.Text)+              (Data.ProtoLens.OptionalField+                 (Data.ProtoLens.Field.field @"maybe'objcClassPrefix")) ::+              Data.ProtoLens.FieldDescriptor FileOptions+        csharpNamespace__field_descriptor+          = Data.ProtoLens.FieldDescriptor+              "csharp_namespace"+              (Data.ProtoLens.ScalarField Data.ProtoLens.StringField ::+                 Data.ProtoLens.FieldTypeDescriptor Data.Text.Text)+              (Data.ProtoLens.OptionalField+                 (Data.ProtoLens.Field.field @"maybe'csharpNamespace")) ::+              Data.ProtoLens.FieldDescriptor FileOptions+        swiftPrefix__field_descriptor+          = Data.ProtoLens.FieldDescriptor+              "swift_prefix"+              (Data.ProtoLens.ScalarField Data.ProtoLens.StringField ::+                 Data.ProtoLens.FieldTypeDescriptor Data.Text.Text)+              (Data.ProtoLens.OptionalField+                 (Data.ProtoLens.Field.field @"maybe'swiftPrefix")) ::+              Data.ProtoLens.FieldDescriptor FileOptions+        phpClassPrefix__field_descriptor+          = Data.ProtoLens.FieldDescriptor+              "php_class_prefix"+              (Data.ProtoLens.ScalarField Data.ProtoLens.StringField ::+                 Data.ProtoLens.FieldTypeDescriptor Data.Text.Text)+              (Data.ProtoLens.OptionalField+                 (Data.ProtoLens.Field.field @"maybe'phpClassPrefix")) ::+              Data.ProtoLens.FieldDescriptor FileOptions+        phpNamespace__field_descriptor+          = Data.ProtoLens.FieldDescriptor+              "php_namespace"+              (Data.ProtoLens.ScalarField Data.ProtoLens.StringField ::+                 Data.ProtoLens.FieldTypeDescriptor Data.Text.Text)+              (Data.ProtoLens.OptionalField+                 (Data.ProtoLens.Field.field @"maybe'phpNamespace")) ::+              Data.ProtoLens.FieldDescriptor FileOptions+        phpMetadataNamespace__field_descriptor+          = Data.ProtoLens.FieldDescriptor+              "php_metadata_namespace"+              (Data.ProtoLens.ScalarField Data.ProtoLens.StringField ::+                 Data.ProtoLens.FieldTypeDescriptor Data.Text.Text)+              (Data.ProtoLens.OptionalField+                 (Data.ProtoLens.Field.field @"maybe'phpMetadataNamespace")) ::+              Data.ProtoLens.FieldDescriptor FileOptions+        rubyPackage__field_descriptor+          = Data.ProtoLens.FieldDescriptor+              "ruby_package"+              (Data.ProtoLens.ScalarField Data.ProtoLens.StringField ::+                 Data.ProtoLens.FieldTypeDescriptor Data.Text.Text)+              (Data.ProtoLens.OptionalField+                 (Data.ProtoLens.Field.field @"maybe'rubyPackage")) ::+              Data.ProtoLens.FieldDescriptor FileOptions+        uninterpretedOption__field_descriptor+          = Data.ProtoLens.FieldDescriptor+              "uninterpreted_option"+              (Data.ProtoLens.MessageField Data.ProtoLens.MessageType ::+                 Data.ProtoLens.FieldTypeDescriptor UninterpretedOption)+              (Data.ProtoLens.RepeatedField+                 Data.ProtoLens.Unpacked+                 (Data.ProtoLens.Field.field @"uninterpretedOption")) ::+              Data.ProtoLens.FieldDescriptor FileOptions+      in+        Data.Map.fromList+          [(Data.ProtoLens.Tag 1, javaPackage__field_descriptor),+           (Data.ProtoLens.Tag 8, javaOuterClassname__field_descriptor),+           (Data.ProtoLens.Tag 10, javaMultipleFiles__field_descriptor),+           (Data.ProtoLens.Tag 20, +            javaGenerateEqualsAndHash__field_descriptor),+           (Data.ProtoLens.Tag 27, javaStringCheckUtf8__field_descriptor),+           (Data.ProtoLens.Tag 9, optimizeFor__field_descriptor),+           (Data.ProtoLens.Tag 11, goPackage__field_descriptor),+           (Data.ProtoLens.Tag 16, ccGenericServices__field_descriptor),+           (Data.ProtoLens.Tag 17, javaGenericServices__field_descriptor),+           (Data.ProtoLens.Tag 18, pyGenericServices__field_descriptor),+           (Data.ProtoLens.Tag 42, phpGenericServices__field_descriptor),+           (Data.ProtoLens.Tag 23, deprecated__field_descriptor),+           (Data.ProtoLens.Tag 31, ccEnableArenas__field_descriptor),+           (Data.ProtoLens.Tag 36, objcClassPrefix__field_descriptor),+           (Data.ProtoLens.Tag 37, csharpNamespace__field_descriptor),+           (Data.ProtoLens.Tag 39, swiftPrefix__field_descriptor),+           (Data.ProtoLens.Tag 40, phpClassPrefix__field_descriptor),+           (Data.ProtoLens.Tag 41, phpNamespace__field_descriptor),+           (Data.ProtoLens.Tag 44, phpMetadataNamespace__field_descriptor),+           (Data.ProtoLens.Tag 45, rubyPackage__field_descriptor),+           (Data.ProtoLens.Tag 999, uninterpretedOption__field_descriptor)]+  unknownFields+    = Lens.Family2.Unchecked.lens+        _FileOptions'_unknownFields+        (\ x__ y__ -> x__ {_FileOptions'_unknownFields = y__})+  defMessage+    = FileOptions'_constructor+        {_FileOptions'javaPackage = Prelude.Nothing,+         _FileOptions'javaOuterClassname = Prelude.Nothing,+         _FileOptions'javaMultipleFiles = Prelude.Nothing,+         _FileOptions'javaGenerateEqualsAndHash = Prelude.Nothing,+         _FileOptions'javaStringCheckUtf8 = Prelude.Nothing,+         _FileOptions'optimizeFor = Prelude.Nothing,+         _FileOptions'goPackage = Prelude.Nothing,+         _FileOptions'ccGenericServices = Prelude.Nothing,+         _FileOptions'javaGenericServices = Prelude.Nothing,+         _FileOptions'pyGenericServices = Prelude.Nothing,+         _FileOptions'phpGenericServices = Prelude.Nothing,+         _FileOptions'deprecated = Prelude.Nothing,+         _FileOptions'ccEnableArenas = Prelude.Nothing,+         _FileOptions'objcClassPrefix = Prelude.Nothing,+         _FileOptions'csharpNamespace = Prelude.Nothing,+         _FileOptions'swiftPrefix = Prelude.Nothing,+         _FileOptions'phpClassPrefix = Prelude.Nothing,+         _FileOptions'phpNamespace = Prelude.Nothing,+         _FileOptions'phpMetadataNamespace = Prelude.Nothing,+         _FileOptions'rubyPackage = Prelude.Nothing,+         _FileOptions'uninterpretedOption = Data.Vector.Generic.empty,+         _FileOptions'_unknownFields = []}+  parseMessage+    = let+        loop ::+          FileOptions+          -> Data.ProtoLens.Encoding.Growing.Growing Data.Vector.Vector Data.ProtoLens.Encoding.Growing.RealWorld UninterpretedOption+             -> Data.ProtoLens.Encoding.Bytes.Parser FileOptions+        loop x mutable'uninterpretedOption+          = do end <- Data.ProtoLens.Encoding.Bytes.atEnd+               if end then+                   do frozen'uninterpretedOption <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO+                                                      (Data.ProtoLens.Encoding.Growing.unsafeFreeze+                                                         mutable'uninterpretedOption)+                      (let missing = []+                       in+                         if Prelude.null missing then+                             Prelude.return ()+                         else+                             Prelude.fail+                               ((Prelude.++)+                                  "Missing required fields: "+                                  (Prelude.show (missing :: [Prelude.String]))))+                      Prelude.return+                        (Lens.Family2.over+                           Data.ProtoLens.unknownFields+                           (\ !t -> Prelude.reverse t)+                           (Lens.Family2.set+                              (Data.ProtoLens.Field.field @"vec'uninterpretedOption")+                              frozen'uninterpretedOption+                              x))+               else+                   do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt+                      case tag of+                        10+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)+                                       (do value <- do len <- Data.ProtoLens.Encoding.Bytes.getVarInt+                                                       Data.ProtoLens.Encoding.Bytes.getBytes+                                                         (Prelude.fromIntegral len)+                                           Data.ProtoLens.Encoding.Bytes.runEither+                                             (case Data.Text.Encoding.decodeUtf8' value of+                                                (Prelude.Left err)+                                                  -> Prelude.Left (Prelude.show err)+                                                (Prelude.Right r) -> Prelude.Right r))+                                       "java_package"+                                loop+                                  (Lens.Family2.set (Data.ProtoLens.Field.field @"javaPackage") y x)+                                  mutable'uninterpretedOption+                        66+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)+                                       (do value <- do len <- Data.ProtoLens.Encoding.Bytes.getVarInt+                                                       Data.ProtoLens.Encoding.Bytes.getBytes+                                                         (Prelude.fromIntegral len)+                                           Data.ProtoLens.Encoding.Bytes.runEither+                                             (case Data.Text.Encoding.decodeUtf8' value of+                                                (Prelude.Left err)+                                                  -> Prelude.Left (Prelude.show err)+                                                (Prelude.Right r) -> Prelude.Right r))+                                       "java_outer_classname"+                                loop+                                  (Lens.Family2.set+                                     (Data.ProtoLens.Field.field @"javaOuterClassname") y x)+                                  mutable'uninterpretedOption+                        80+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)+                                       (Prelude.fmap+                                          ((Prelude./=) 0) Data.ProtoLens.Encoding.Bytes.getVarInt)+                                       "java_multiple_files"+                                loop+                                  (Lens.Family2.set+                                     (Data.ProtoLens.Field.field @"javaMultipleFiles") y x)+                                  mutable'uninterpretedOption+                        160+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)+                                       (Prelude.fmap+                                          ((Prelude./=) 0) Data.ProtoLens.Encoding.Bytes.getVarInt)+                                       "java_generate_equals_and_hash"+                                loop+                                  (Lens.Family2.set+                                     (Data.ProtoLens.Field.field @"javaGenerateEqualsAndHash") y x)+                                  mutable'uninterpretedOption+                        216+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)+                                       (Prelude.fmap+                                          ((Prelude./=) 0) Data.ProtoLens.Encoding.Bytes.getVarInt)+                                       "java_string_check_utf8"+                                loop+                                  (Lens.Family2.set+                                     (Data.ProtoLens.Field.field @"javaStringCheckUtf8") y x)+                                  mutable'uninterpretedOption+                        72+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)+                                       (Prelude.fmap+                                          Prelude.toEnum+                                          (Prelude.fmap+                                             Prelude.fromIntegral+                                             Data.ProtoLens.Encoding.Bytes.getVarInt))+                                       "optimize_for"+                                loop+                                  (Lens.Family2.set (Data.ProtoLens.Field.field @"optimizeFor") y x)+                                  mutable'uninterpretedOption+                        90+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)+                                       (do value <- do len <- Data.ProtoLens.Encoding.Bytes.getVarInt+                                                       Data.ProtoLens.Encoding.Bytes.getBytes+                                                         (Prelude.fromIntegral len)+                                           Data.ProtoLens.Encoding.Bytes.runEither+                                             (case Data.Text.Encoding.decodeUtf8' value of+                                                (Prelude.Left err)+                                                  -> Prelude.Left (Prelude.show err)+                                                (Prelude.Right r) -> Prelude.Right r))+                                       "go_package"+                                loop+                                  (Lens.Family2.set (Data.ProtoLens.Field.field @"goPackage") y x)+                                  mutable'uninterpretedOption+                        128+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)+                                       (Prelude.fmap+                                          ((Prelude./=) 0) Data.ProtoLens.Encoding.Bytes.getVarInt)+                                       "cc_generic_services"+                                loop+                                  (Lens.Family2.set+                                     (Data.ProtoLens.Field.field @"ccGenericServices") y x)+                                  mutable'uninterpretedOption+                        136+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)+                                       (Prelude.fmap+                                          ((Prelude./=) 0) Data.ProtoLens.Encoding.Bytes.getVarInt)+                                       "java_generic_services"+                                loop+                                  (Lens.Family2.set+                                     (Data.ProtoLens.Field.field @"javaGenericServices") y x)+                                  mutable'uninterpretedOption+                        144+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)+                                       (Prelude.fmap+                                          ((Prelude./=) 0) Data.ProtoLens.Encoding.Bytes.getVarInt)+                                       "py_generic_services"+                                loop+                                  (Lens.Family2.set+                                     (Data.ProtoLens.Field.field @"pyGenericServices") y x)+                                  mutable'uninterpretedOption+                        336+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)+                                       (Prelude.fmap+                                          ((Prelude./=) 0) Data.ProtoLens.Encoding.Bytes.getVarInt)+                                       "php_generic_services"+                                loop+                                  (Lens.Family2.set+                                     (Data.ProtoLens.Field.field @"phpGenericServices") y x)+                                  mutable'uninterpretedOption+                        184+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)+                                       (Prelude.fmap+                                          ((Prelude./=) 0) Data.ProtoLens.Encoding.Bytes.getVarInt)+                                       "deprecated"+                                loop+                                  (Lens.Family2.set (Data.ProtoLens.Field.field @"deprecated") y x)+                                  mutable'uninterpretedOption+                        248+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)+                                       (Prelude.fmap+                                          ((Prelude./=) 0) Data.ProtoLens.Encoding.Bytes.getVarInt)+                                       "cc_enable_arenas"+                                loop+                                  (Lens.Family2.set+                                     (Data.ProtoLens.Field.field @"ccEnableArenas") y x)+                                  mutable'uninterpretedOption+                        290+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)+                                       (do value <- do len <- Data.ProtoLens.Encoding.Bytes.getVarInt+                                                       Data.ProtoLens.Encoding.Bytes.getBytes+                                                         (Prelude.fromIntegral len)+                                           Data.ProtoLens.Encoding.Bytes.runEither+                                             (case Data.Text.Encoding.decodeUtf8' value of+                                                (Prelude.Left err)+                                                  -> Prelude.Left (Prelude.show err)+                                                (Prelude.Right r) -> Prelude.Right r))+                                       "objc_class_prefix"+                                loop+                                  (Lens.Family2.set+                                     (Data.ProtoLens.Field.field @"objcClassPrefix") y x)+                                  mutable'uninterpretedOption+                        298+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)+                                       (do value <- do len <- Data.ProtoLens.Encoding.Bytes.getVarInt+                                                       Data.ProtoLens.Encoding.Bytes.getBytes+                                                         (Prelude.fromIntegral len)+                                           Data.ProtoLens.Encoding.Bytes.runEither+                                             (case Data.Text.Encoding.decodeUtf8' value of+                                                (Prelude.Left err)+                                                  -> Prelude.Left (Prelude.show err)+                                                (Prelude.Right r) -> Prelude.Right r))+                                       "csharp_namespace"+                                loop+                                  (Lens.Family2.set+                                     (Data.ProtoLens.Field.field @"csharpNamespace") y x)+                                  mutable'uninterpretedOption+                        314+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)+                                       (do value <- do len <- Data.ProtoLens.Encoding.Bytes.getVarInt+                                                       Data.ProtoLens.Encoding.Bytes.getBytes+                                                         (Prelude.fromIntegral len)+                                           Data.ProtoLens.Encoding.Bytes.runEither+                                             (case Data.Text.Encoding.decodeUtf8' value of+                                                (Prelude.Left err)+                                                  -> Prelude.Left (Prelude.show err)+                                                (Prelude.Right r) -> Prelude.Right r))+                                       "swift_prefix"+                                loop+                                  (Lens.Family2.set (Data.ProtoLens.Field.field @"swiftPrefix") y x)+                                  mutable'uninterpretedOption+                        322+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)+                                       (do value <- do len <- Data.ProtoLens.Encoding.Bytes.getVarInt+                                                       Data.ProtoLens.Encoding.Bytes.getBytes+                                                         (Prelude.fromIntegral len)+                                           Data.ProtoLens.Encoding.Bytes.runEither+                                             (case Data.Text.Encoding.decodeUtf8' value of+                                                (Prelude.Left err)+                                                  -> Prelude.Left (Prelude.show err)+                                                (Prelude.Right r) -> Prelude.Right r))+                                       "php_class_prefix"+                                loop+                                  (Lens.Family2.set+                                     (Data.ProtoLens.Field.field @"phpClassPrefix") y x)+                                  mutable'uninterpretedOption+                        330+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)+                                       (do value <- do len <- Data.ProtoLens.Encoding.Bytes.getVarInt+                                                       Data.ProtoLens.Encoding.Bytes.getBytes+                                                         (Prelude.fromIntegral len)+                                           Data.ProtoLens.Encoding.Bytes.runEither+                                             (case Data.Text.Encoding.decodeUtf8' value of+                                                (Prelude.Left err)+                                                  -> Prelude.Left (Prelude.show err)+                                                (Prelude.Right r) -> Prelude.Right r))+                                       "php_namespace"+                                loop+                                  (Lens.Family2.set+                                     (Data.ProtoLens.Field.field @"phpNamespace") y x)+                                  mutable'uninterpretedOption+                        354+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)+                                       (do value <- do len <- Data.ProtoLens.Encoding.Bytes.getVarInt+                                                       Data.ProtoLens.Encoding.Bytes.getBytes+                                                         (Prelude.fromIntegral len)+                                           Data.ProtoLens.Encoding.Bytes.runEither+                                             (case Data.Text.Encoding.decodeUtf8' value of+                                                (Prelude.Left err)+                                                  -> Prelude.Left (Prelude.show err)+                                                (Prelude.Right r) -> Prelude.Right r))+                                       "php_metadata_namespace"+                                loop+                                  (Lens.Family2.set+                                     (Data.ProtoLens.Field.field @"phpMetadataNamespace") y x)+                                  mutable'uninterpretedOption+                        362+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)+                                       (do value <- do len <- Data.ProtoLens.Encoding.Bytes.getVarInt+                                                       Data.ProtoLens.Encoding.Bytes.getBytes+                                                         (Prelude.fromIntegral len)+                                           Data.ProtoLens.Encoding.Bytes.runEither+                                             (case Data.Text.Encoding.decodeUtf8' value of+                                                (Prelude.Left err)+                                                  -> Prelude.Left (Prelude.show err)+                                                (Prelude.Right r) -> Prelude.Right r))+                                       "ruby_package"+                                loop+                                  (Lens.Family2.set (Data.ProtoLens.Field.field @"rubyPackage") y x)+                                  mutable'uninterpretedOption+                        7994+                          -> do !y <- (Data.ProtoLens.Encoding.Bytes.<?>)+                                        (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt+                                            Data.ProtoLens.Encoding.Bytes.isolate+                                              (Prelude.fromIntegral len)+                                              Data.ProtoLens.parseMessage)+                                        "uninterpreted_option"+                                v <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO+                                       (Data.ProtoLens.Encoding.Growing.append+                                          mutable'uninterpretedOption y)+                                loop x v+                        wire+                          -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire+                                        wire+                                loop+                                  (Lens.Family2.over+                                     Data.ProtoLens.unknownFields (\ !t -> (:) y t) x)+                                  mutable'uninterpretedOption+      in+        (Data.ProtoLens.Encoding.Bytes.<?>)+          (do mutable'uninterpretedOption <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO+                                               Data.ProtoLens.Encoding.Growing.new+              loop Data.ProtoLens.defMessage mutable'uninterpretedOption)+          "FileOptions"+  buildMessage+    = \ _x+        -> (Data.Monoid.<>)+             (case+                  Lens.Family2.view+                    (Data.ProtoLens.Field.field @"maybe'javaPackage") _x+              of+                Prelude.Nothing -> Data.Monoid.mempty+                (Prelude.Just _v)+                  -> (Data.Monoid.<>)+                       (Data.ProtoLens.Encoding.Bytes.putVarInt 10)+                       ((Prelude..)+                          (\ bs+                             -> (Data.Monoid.<>)+                                  (Data.ProtoLens.Encoding.Bytes.putVarInt+                                     (Prelude.fromIntegral (Data.ByteString.length bs)))+                                  (Data.ProtoLens.Encoding.Bytes.putBytes bs))+                          Data.Text.Encoding.encodeUtf8+                          _v))+             ((Data.Monoid.<>)+                (case+                     Lens.Family2.view+                       (Data.ProtoLens.Field.field @"maybe'javaOuterClassname") _x+                 of+                   Prelude.Nothing -> Data.Monoid.mempty+                   (Prelude.Just _v)+                     -> (Data.Monoid.<>)+                          (Data.ProtoLens.Encoding.Bytes.putVarInt 66)+                          ((Prelude..)+                             (\ bs+                                -> (Data.Monoid.<>)+                                     (Data.ProtoLens.Encoding.Bytes.putVarInt+                                        (Prelude.fromIntegral (Data.ByteString.length bs)))+                                     (Data.ProtoLens.Encoding.Bytes.putBytes bs))+                             Data.Text.Encoding.encodeUtf8+                             _v))+                ((Data.Monoid.<>)+                   (case+                        Lens.Family2.view+                          (Data.ProtoLens.Field.field @"maybe'javaMultipleFiles") _x+                    of+                      Prelude.Nothing -> Data.Monoid.mempty+                      (Prelude.Just _v)+                        -> (Data.Monoid.<>)+                             (Data.ProtoLens.Encoding.Bytes.putVarInt 80)+                             ((Prelude..)+                                Data.ProtoLens.Encoding.Bytes.putVarInt+                                (\ b -> if b then 1 else 0)+                                _v))+                   ((Data.Monoid.<>)+                      (case+                           Lens.Family2.view+                             (Data.ProtoLens.Field.field @"maybe'javaGenerateEqualsAndHash") _x+                       of+                         Prelude.Nothing -> Data.Monoid.mempty+                         (Prelude.Just _v)+                           -> (Data.Monoid.<>)+                                (Data.ProtoLens.Encoding.Bytes.putVarInt 160)+                                ((Prelude..)+                                   Data.ProtoLens.Encoding.Bytes.putVarInt+                                   (\ b -> if b then 1 else 0)+                                   _v))+                      ((Data.Monoid.<>)+                         (case+                              Lens.Family2.view+                                (Data.ProtoLens.Field.field @"maybe'javaStringCheckUtf8") _x+                          of+                            Prelude.Nothing -> Data.Monoid.mempty+                            (Prelude.Just _v)+                              -> (Data.Monoid.<>)+                                   (Data.ProtoLens.Encoding.Bytes.putVarInt 216)+                                   ((Prelude..)+                                      Data.ProtoLens.Encoding.Bytes.putVarInt+                                      (\ b -> if b then 1 else 0)+                                      _v))+                         ((Data.Monoid.<>)+                            (case+                                 Lens.Family2.view+                                   (Data.ProtoLens.Field.field @"maybe'optimizeFor") _x+                             of+                               Prelude.Nothing -> Data.Monoid.mempty+                               (Prelude.Just _v)+                                 -> (Data.Monoid.<>)+                                      (Data.ProtoLens.Encoding.Bytes.putVarInt 72)+                                      ((Prelude..)+                                         ((Prelude..)+                                            Data.ProtoLens.Encoding.Bytes.putVarInt+                                            Prelude.fromIntegral)+                                         Prelude.fromEnum+                                         _v))+                            ((Data.Monoid.<>)+                               (case+                                    Lens.Family2.view+                                      (Data.ProtoLens.Field.field @"maybe'goPackage") _x+                                of+                                  Prelude.Nothing -> Data.Monoid.mempty+                                  (Prelude.Just _v)+                                    -> (Data.Monoid.<>)+                                         (Data.ProtoLens.Encoding.Bytes.putVarInt 90)+                                         ((Prelude..)+                                            (\ bs+                                               -> (Data.Monoid.<>)+                                                    (Data.ProtoLens.Encoding.Bytes.putVarInt+                                                       (Prelude.fromIntegral+                                                          (Data.ByteString.length bs)))+                                                    (Data.ProtoLens.Encoding.Bytes.putBytes bs))+                                            Data.Text.Encoding.encodeUtf8+                                            _v))+                               ((Data.Monoid.<>)+                                  (case+                                       Lens.Family2.view+                                         (Data.ProtoLens.Field.field @"maybe'ccGenericServices") _x+                                   of+                                     Prelude.Nothing -> Data.Monoid.mempty+                                     (Prelude.Just _v)+                                       -> (Data.Monoid.<>)+                                            (Data.ProtoLens.Encoding.Bytes.putVarInt 128)+                                            ((Prelude..)+                                               Data.ProtoLens.Encoding.Bytes.putVarInt+                                               (\ b -> if b then 1 else 0)+                                               _v))+                                  ((Data.Monoid.<>)+                                     (case+                                          Lens.Family2.view+                                            (Data.ProtoLens.Field.field+                                               @"maybe'javaGenericServices")+                                            _x+                                      of+                                        Prelude.Nothing -> Data.Monoid.mempty+                                        (Prelude.Just _v)+                                          -> (Data.Monoid.<>)+                                               (Data.ProtoLens.Encoding.Bytes.putVarInt 136)+                                               ((Prelude..)+                                                  Data.ProtoLens.Encoding.Bytes.putVarInt+                                                  (\ b -> if b then 1 else 0)+                                                  _v))+                                     ((Data.Monoid.<>)+                                        (case+                                             Lens.Family2.view+                                               (Data.ProtoLens.Field.field+                                                  @"maybe'pyGenericServices")+                                               _x+                                         of+                                           Prelude.Nothing -> Data.Monoid.mempty+                                           (Prelude.Just _v)+                                             -> (Data.Monoid.<>)+                                                  (Data.ProtoLens.Encoding.Bytes.putVarInt 144)+                                                  ((Prelude..)+                                                     Data.ProtoLens.Encoding.Bytes.putVarInt+                                                     (\ b -> if b then 1 else 0)+                                                     _v))+                                        ((Data.Monoid.<>)+                                           (case+                                                Lens.Family2.view+                                                  (Data.ProtoLens.Field.field+                                                     @"maybe'phpGenericServices")+                                                  _x+                                            of+                                              Prelude.Nothing -> Data.Monoid.mempty+                                              (Prelude.Just _v)+                                                -> (Data.Monoid.<>)+                                                     (Data.ProtoLens.Encoding.Bytes.putVarInt 336)+                                                     ((Prelude..)+                                                        Data.ProtoLens.Encoding.Bytes.putVarInt+                                                        (\ b -> if b then 1 else 0)+                                                        _v))+                                           ((Data.Monoid.<>)+                                              (case+                                                   Lens.Family2.view+                                                     (Data.ProtoLens.Field.field+                                                        @"maybe'deprecated")+                                                     _x+                                               of+                                                 Prelude.Nothing -> Data.Monoid.mempty+                                                 (Prelude.Just _v)+                                                   -> (Data.Monoid.<>)+                                                        (Data.ProtoLens.Encoding.Bytes.putVarInt+                                                           184)+                                                        ((Prelude..)+                                                           Data.ProtoLens.Encoding.Bytes.putVarInt+                                                           (\ b -> if b then 1 else 0)+                                                           _v))+                                              ((Data.Monoid.<>)+                                                 (case+                                                      Lens.Family2.view+                                                        (Data.ProtoLens.Field.field+                                                           @"maybe'ccEnableArenas")+                                                        _x+                                                  of+                                                    Prelude.Nothing -> Data.Monoid.mempty+                                                    (Prelude.Just _v)+                                                      -> (Data.Monoid.<>)+                                                           (Data.ProtoLens.Encoding.Bytes.putVarInt+                                                              248)+                                                           ((Prelude..)+                                                              Data.ProtoLens.Encoding.Bytes.putVarInt+                                                              (\ b -> if b then 1 else 0)+                                                              _v))+                                                 ((Data.Monoid.<>)+                                                    (case+                                                         Lens.Family2.view+                                                           (Data.ProtoLens.Field.field+                                                              @"maybe'objcClassPrefix")+                                                           _x+                                                     of+                                                       Prelude.Nothing -> Data.Monoid.mempty+                                                       (Prelude.Just _v)+                                                         -> (Data.Monoid.<>)+                                                              (Data.ProtoLens.Encoding.Bytes.putVarInt+                                                                 290)+                                                              ((Prelude..)+                                                                 (\ bs+                                                                    -> (Data.Monoid.<>)+                                                                         (Data.ProtoLens.Encoding.Bytes.putVarInt+                                                                            (Prelude.fromIntegral+                                                                               (Data.ByteString.length+                                                                                  bs)))+                                                                         (Data.ProtoLens.Encoding.Bytes.putBytes+                                                                            bs))+                                                                 Data.Text.Encoding.encodeUtf8+                                                                 _v))+                                                    ((Data.Monoid.<>)+                                                       (case+                                                            Lens.Family2.view+                                                              (Data.ProtoLens.Field.field+                                                                 @"maybe'csharpNamespace")+                                                              _x+                                                        of+                                                          Prelude.Nothing -> Data.Monoid.mempty+                                                          (Prelude.Just _v)+                                                            -> (Data.Monoid.<>)+                                                                 (Data.ProtoLens.Encoding.Bytes.putVarInt+                                                                    298)+                                                                 ((Prelude..)+                                                                    (\ bs+                                                                       -> (Data.Monoid.<>)+                                                                            (Data.ProtoLens.Encoding.Bytes.putVarInt+                                                                               (Prelude.fromIntegral+                                                                                  (Data.ByteString.length+                                                                                     bs)))+                                                                            (Data.ProtoLens.Encoding.Bytes.putBytes+                                                                               bs))+                                                                    Data.Text.Encoding.encodeUtf8+                                                                    _v))+                                                       ((Data.Monoid.<>)+                                                          (case+                                                               Lens.Family2.view+                                                                 (Data.ProtoLens.Field.field+                                                                    @"maybe'swiftPrefix")+                                                                 _x+                                                           of+                                                             Prelude.Nothing -> Data.Monoid.mempty+                                                             (Prelude.Just _v)+                                                               -> (Data.Monoid.<>)+                                                                    (Data.ProtoLens.Encoding.Bytes.putVarInt+                                                                       314)+                                                                    ((Prelude..)+                                                                       (\ bs+                                                                          -> (Data.Monoid.<>)+                                                                               (Data.ProtoLens.Encoding.Bytes.putVarInt+                                                                                  (Prelude.fromIntegral+                                                                                     (Data.ByteString.length+                                                                                        bs)))+                                                                               (Data.ProtoLens.Encoding.Bytes.putBytes+                                                                                  bs))+                                                                       Data.Text.Encoding.encodeUtf8+                                                                       _v))+                                                          ((Data.Monoid.<>)+                                                             (case+                                                                  Lens.Family2.view+                                                                    (Data.ProtoLens.Field.field+                                                                       @"maybe'phpClassPrefix")+                                                                    _x+                                                              of+                                                                Prelude.Nothing+                                                                  -> Data.Monoid.mempty+                                                                (Prelude.Just _v)+                                                                  -> (Data.Monoid.<>)+                                                                       (Data.ProtoLens.Encoding.Bytes.putVarInt+                                                                          322)+                                                                       ((Prelude..)+                                                                          (\ bs+                                                                             -> (Data.Monoid.<>)+                                                                                  (Data.ProtoLens.Encoding.Bytes.putVarInt+                                                                                     (Prelude.fromIntegral+                                                                                        (Data.ByteString.length+                                                                                           bs)))+                                                                                  (Data.ProtoLens.Encoding.Bytes.putBytes+                                                                                     bs))+                                                                          Data.Text.Encoding.encodeUtf8+                                                                          _v))+                                                             ((Data.Monoid.<>)+                                                                (case+                                                                     Lens.Family2.view+                                                                       (Data.ProtoLens.Field.field+                                                                          @"maybe'phpNamespace")+                                                                       _x+                                                                 of+                                                                   Prelude.Nothing+                                                                     -> Data.Monoid.mempty+                                                                   (Prelude.Just _v)+                                                                     -> (Data.Monoid.<>)+                                                                          (Data.ProtoLens.Encoding.Bytes.putVarInt+                                                                             330)+                                                                          ((Prelude..)+                                                                             (\ bs+                                                                                -> (Data.Monoid.<>)+                                                                                     (Data.ProtoLens.Encoding.Bytes.putVarInt+                                                                                        (Prelude.fromIntegral+                                                                                           (Data.ByteString.length+                                                                                              bs)))+                                                                                     (Data.ProtoLens.Encoding.Bytes.putBytes+                                                                                        bs))+                                                                             Data.Text.Encoding.encodeUtf8+                                                                             _v))+                                                                ((Data.Monoid.<>)+                                                                   (case+                                                                        Lens.Family2.view+                                                                          (Data.ProtoLens.Field.field+                                                                             @"maybe'phpMetadataNamespace")+                                                                          _x+                                                                    of+                                                                      Prelude.Nothing+                                                                        -> Data.Monoid.mempty+                                                                      (Prelude.Just _v)+                                                                        -> (Data.Monoid.<>)+                                                                             (Data.ProtoLens.Encoding.Bytes.putVarInt+                                                                                354)+                                                                             ((Prelude..)+                                                                                (\ bs+                                                                                   -> (Data.Monoid.<>)+                                                                                        (Data.ProtoLens.Encoding.Bytes.putVarInt+                                                                                           (Prelude.fromIntegral+                                                                                              (Data.ByteString.length+                                                                                                 bs)))+                                                                                        (Data.ProtoLens.Encoding.Bytes.putBytes+                                                                                           bs))+                                                                                Data.Text.Encoding.encodeUtf8+                                                                                _v))+                                                                   ((Data.Monoid.<>)+                                                                      (case+                                                                           Lens.Family2.view+                                                                             (Data.ProtoLens.Field.field+                                                                                @"maybe'rubyPackage")+                                                                             _x+                                                                       of+                                                                         Prelude.Nothing+                                                                           -> Data.Monoid.mempty+                                                                         (Prelude.Just _v)+                                                                           -> (Data.Monoid.<>)+                                                                                (Data.ProtoLens.Encoding.Bytes.putVarInt+                                                                                   362)+                                                                                ((Prelude..)+                                                                                   (\ bs+                                                                                      -> (Data.Monoid.<>)+                                                                                           (Data.ProtoLens.Encoding.Bytes.putVarInt+                                                                                              (Prelude.fromIntegral+                                                                                                 (Data.ByteString.length+                                                                                                    bs)))+                                                                                           (Data.ProtoLens.Encoding.Bytes.putBytes+                                                                                              bs))+                                                                                   Data.Text.Encoding.encodeUtf8+                                                                                   _v))+                                                                      ((Data.Monoid.<>)+                                                                         (Data.ProtoLens.Encoding.Bytes.foldMapBuilder+                                                                            (\ _v+                                                                               -> (Data.Monoid.<>)+                                                                                    (Data.ProtoLens.Encoding.Bytes.putVarInt+                                                                                       7994)+                                                                                    ((Prelude..)+                                                                                       (\ bs+                                                                                          -> (Data.Monoid.<>)+                                                                                               (Data.ProtoLens.Encoding.Bytes.putVarInt+                                                                                                  (Prelude.fromIntegral+                                                                                                     (Data.ByteString.length+                                                                                                        bs)))+                                                                                               (Data.ProtoLens.Encoding.Bytes.putBytes+                                                                                                  bs))+                                                                                       Data.ProtoLens.encodeMessage+                                                                                       _v))+                                                                            (Lens.Family2.view+                                                                               (Data.ProtoLens.Field.field+                                                                                  @"vec'uninterpretedOption")+                                                                               _x))+                                                                         (Data.ProtoLens.Encoding.Wire.buildFieldSet+                                                                            (Lens.Family2.view+                                                                               Data.ProtoLens.unknownFields+                                                                               _x))))))))))))))))))))))+instance Control.DeepSeq.NFData FileOptions where+  rnf+    = \ x__+        -> Control.DeepSeq.deepseq+             (_FileOptions'_unknownFields x__)+             (Control.DeepSeq.deepseq+                (_FileOptions'javaPackage x__)+                (Control.DeepSeq.deepseq+                   (_FileOptions'javaOuterClassname x__)+                   (Control.DeepSeq.deepseq+                      (_FileOptions'javaMultipleFiles x__)+                      (Control.DeepSeq.deepseq+                         (_FileOptions'javaGenerateEqualsAndHash x__)+                         (Control.DeepSeq.deepseq+                            (_FileOptions'javaStringCheckUtf8 x__)+                            (Control.DeepSeq.deepseq+                               (_FileOptions'optimizeFor x__)+                               (Control.DeepSeq.deepseq+                                  (_FileOptions'goPackage x__)+                                  (Control.DeepSeq.deepseq+                                     (_FileOptions'ccGenericServices x__)+                                     (Control.DeepSeq.deepseq+                                        (_FileOptions'javaGenericServices x__)+                                        (Control.DeepSeq.deepseq+                                           (_FileOptions'pyGenericServices x__)+                                           (Control.DeepSeq.deepseq+                                              (_FileOptions'phpGenericServices x__)+                                              (Control.DeepSeq.deepseq+                                                 (_FileOptions'deprecated x__)+                                                 (Control.DeepSeq.deepseq+                                                    (_FileOptions'ccEnableArenas x__)+                                                    (Control.DeepSeq.deepseq+                                                       (_FileOptions'objcClassPrefix x__)+                                                       (Control.DeepSeq.deepseq+                                                          (_FileOptions'csharpNamespace x__)+                                                          (Control.DeepSeq.deepseq+                                                             (_FileOptions'swiftPrefix x__)+                                                             (Control.DeepSeq.deepseq+                                                                (_FileOptions'phpClassPrefix x__)+                                                                (Control.DeepSeq.deepseq+                                                                   (_FileOptions'phpNamespace x__)+                                                                   (Control.DeepSeq.deepseq+                                                                      (_FileOptions'phpMetadataNamespace+                                                                         x__)+                                                                      (Control.DeepSeq.deepseq+                                                                         (_FileOptions'rubyPackage+                                                                            x__)+                                                                         (Control.DeepSeq.deepseq+                                                                            (_FileOptions'uninterpretedOption+                                                                               x__)+                                                                            ())))))))))))))))))))))+data FileOptions'OptimizeMode+  = FileOptions'SPEED |+    FileOptions'CODE_SIZE |+    FileOptions'LITE_RUNTIME+  deriving (Prelude.Show, Prelude.Eq, Prelude.Ord)+instance Data.ProtoLens.MessageEnum FileOptions'OptimizeMode where+  maybeToEnum 1 = Prelude.Just FileOptions'SPEED+  maybeToEnum 2 = Prelude.Just FileOptions'CODE_SIZE+  maybeToEnum 3 = Prelude.Just FileOptions'LITE_RUNTIME+  maybeToEnum _ = Prelude.Nothing+  showEnum FileOptions'SPEED = "SPEED"+  showEnum FileOptions'CODE_SIZE = "CODE_SIZE"+  showEnum FileOptions'LITE_RUNTIME = "LITE_RUNTIME"+  readEnum k+    | (Prelude.==) k "SPEED" = Prelude.Just FileOptions'SPEED+    | (Prelude.==) k "CODE_SIZE" = Prelude.Just FileOptions'CODE_SIZE+    | (Prelude.==) k "LITE_RUNTIME"+    = Prelude.Just FileOptions'LITE_RUNTIME+    | Prelude.otherwise+    = (Prelude.>>=) (Text.Read.readMaybe k) Data.ProtoLens.maybeToEnum+instance Prelude.Bounded FileOptions'OptimizeMode where+  minBound = FileOptions'SPEED+  maxBound = FileOptions'LITE_RUNTIME+instance Prelude.Enum FileOptions'OptimizeMode where+  toEnum k__+    = Prelude.maybe+        (Prelude.error+           ((Prelude.++)+              "toEnum: unknown value for enum OptimizeMode: "+              (Prelude.show k__)))+        Prelude.id+        (Data.ProtoLens.maybeToEnum k__)+  fromEnum FileOptions'SPEED = 1+  fromEnum FileOptions'CODE_SIZE = 2+  fromEnum FileOptions'LITE_RUNTIME = 3+  succ FileOptions'LITE_RUNTIME+    = Prelude.error+        "FileOptions'OptimizeMode.succ: bad argument FileOptions'LITE_RUNTIME. This value would be out of bounds."+  succ FileOptions'SPEED = FileOptions'CODE_SIZE+  succ FileOptions'CODE_SIZE = FileOptions'LITE_RUNTIME+  pred FileOptions'SPEED+    = Prelude.error+        "FileOptions'OptimizeMode.pred: bad argument FileOptions'SPEED. This value would be out of bounds."+  pred FileOptions'CODE_SIZE = FileOptions'SPEED+  pred FileOptions'LITE_RUNTIME = FileOptions'CODE_SIZE+  enumFrom = Data.ProtoLens.Message.Enum.messageEnumFrom+  enumFromTo = Data.ProtoLens.Message.Enum.messageEnumFromTo+  enumFromThen = Data.ProtoLens.Message.Enum.messageEnumFromThen+  enumFromThenTo = Data.ProtoLens.Message.Enum.messageEnumFromThenTo+instance Data.ProtoLens.FieldDefault FileOptions'OptimizeMode where+  fieldDefault = FileOptions'SPEED+instance Control.DeepSeq.NFData FileOptions'OptimizeMode where+  rnf x__ = Prelude.seq x__ ()+{- | Fields :+     +         * 'Proto.Google.Protobuf.Descriptor_Fields.annotation' @:: Lens' GeneratedCodeInfo [GeneratedCodeInfo'Annotation]@+         * 'Proto.Google.Protobuf.Descriptor_Fields.vec'annotation' @:: Lens' GeneratedCodeInfo (Data.Vector.Vector GeneratedCodeInfo'Annotation)@ -}+data GeneratedCodeInfo+  = GeneratedCodeInfo'_constructor {_GeneratedCodeInfo'annotation :: !(Data.Vector.Vector GeneratedCodeInfo'Annotation),+                                    _GeneratedCodeInfo'_unknownFields :: !Data.ProtoLens.FieldSet}+  deriving (Prelude.Eq, Prelude.Ord)+instance Prelude.Show GeneratedCodeInfo where+  showsPrec _ __x __s+    = Prelude.showChar+        '{'+        (Prelude.showString+           (Data.ProtoLens.showMessageShort __x) (Prelude.showChar '}' __s))+instance Data.ProtoLens.Field.HasField GeneratedCodeInfo "annotation" [GeneratedCodeInfo'Annotation] where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _GeneratedCodeInfo'annotation+           (\ x__ y__ -> x__ {_GeneratedCodeInfo'annotation = y__}))+        (Lens.Family2.Unchecked.lens+           Data.Vector.Generic.toList+           (\ _ y__ -> Data.Vector.Generic.fromList y__))+instance Data.ProtoLens.Field.HasField GeneratedCodeInfo "vec'annotation" (Data.Vector.Vector GeneratedCodeInfo'Annotation) where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _GeneratedCodeInfo'annotation+           (\ x__ y__ -> x__ {_GeneratedCodeInfo'annotation = y__}))+        Prelude.id+instance Data.ProtoLens.Message GeneratedCodeInfo where+  messageName _ = Data.Text.pack "google.protobuf.GeneratedCodeInfo"+  fieldsByTag+    = let+        annotation__field_descriptor+          = Data.ProtoLens.FieldDescriptor+              "annotation"+              (Data.ProtoLens.MessageField Data.ProtoLens.MessageType ::+                 Data.ProtoLens.FieldTypeDescriptor GeneratedCodeInfo'Annotation)+              (Data.ProtoLens.RepeatedField+                 Data.ProtoLens.Unpacked+                 (Data.ProtoLens.Field.field @"annotation")) ::+              Data.ProtoLens.FieldDescriptor GeneratedCodeInfo+      in+        Data.Map.fromList+          [(Data.ProtoLens.Tag 1, annotation__field_descriptor)]+  unknownFields+    = Lens.Family2.Unchecked.lens+        _GeneratedCodeInfo'_unknownFields+        (\ x__ y__ -> x__ {_GeneratedCodeInfo'_unknownFields = y__})+  defMessage+    = GeneratedCodeInfo'_constructor+        {_GeneratedCodeInfo'annotation = Data.Vector.Generic.empty,+         _GeneratedCodeInfo'_unknownFields = []}+  parseMessage+    = let+        loop ::+          GeneratedCodeInfo+          -> Data.ProtoLens.Encoding.Growing.Growing Data.Vector.Vector Data.ProtoLens.Encoding.Growing.RealWorld GeneratedCodeInfo'Annotation+             -> Data.ProtoLens.Encoding.Bytes.Parser GeneratedCodeInfo+        loop x mutable'annotation+          = do end <- Data.ProtoLens.Encoding.Bytes.atEnd+               if end then+                   do frozen'annotation <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO+                                             (Data.ProtoLens.Encoding.Growing.unsafeFreeze+                                                mutable'annotation)+                      (let missing = []+                       in+                         if Prelude.null missing then+                             Prelude.return ()+                         else+                             Prelude.fail+                               ((Prelude.++)+                                  "Missing required fields: "+                                  (Prelude.show (missing :: [Prelude.String]))))+                      Prelude.return+                        (Lens.Family2.over+                           Data.ProtoLens.unknownFields+                           (\ !t -> Prelude.reverse t)+                           (Lens.Family2.set+                              (Data.ProtoLens.Field.field @"vec'annotation")+                              frozen'annotation+                              x))+               else+                   do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt+                      case tag of+                        10+                          -> do !y <- (Data.ProtoLens.Encoding.Bytes.<?>)+                                        (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt+                                            Data.ProtoLens.Encoding.Bytes.isolate+                                              (Prelude.fromIntegral len)+                                              Data.ProtoLens.parseMessage)+                                        "annotation"+                                v <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO+                                       (Data.ProtoLens.Encoding.Growing.append mutable'annotation y)+                                loop x v+                        wire+                          -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire+                                        wire+                                loop+                                  (Lens.Family2.over+                                     Data.ProtoLens.unknownFields (\ !t -> (:) y t) x)+                                  mutable'annotation+      in+        (Data.ProtoLens.Encoding.Bytes.<?>)+          (do mutable'annotation <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO+                                      Data.ProtoLens.Encoding.Growing.new+              loop Data.ProtoLens.defMessage mutable'annotation)+          "GeneratedCodeInfo"+  buildMessage+    = \ _x+        -> (Data.Monoid.<>)+             (Data.ProtoLens.Encoding.Bytes.foldMapBuilder+                (\ _v+                   -> (Data.Monoid.<>)+                        (Data.ProtoLens.Encoding.Bytes.putVarInt 10)+                        ((Prelude..)+                           (\ bs+                              -> (Data.Monoid.<>)+                                   (Data.ProtoLens.Encoding.Bytes.putVarInt+                                      (Prelude.fromIntegral (Data.ByteString.length bs)))+                                   (Data.ProtoLens.Encoding.Bytes.putBytes bs))+                           Data.ProtoLens.encodeMessage+                           _v))+                (Lens.Family2.view+                   (Data.ProtoLens.Field.field @"vec'annotation") _x))+             (Data.ProtoLens.Encoding.Wire.buildFieldSet+                (Lens.Family2.view Data.ProtoLens.unknownFields _x))+instance Control.DeepSeq.NFData GeneratedCodeInfo where+  rnf+    = \ x__+        -> Control.DeepSeq.deepseq+             (_GeneratedCodeInfo'_unknownFields x__)+             (Control.DeepSeq.deepseq (_GeneratedCodeInfo'annotation x__) ())+{- | Fields :+     +         * 'Proto.Google.Protobuf.Descriptor_Fields.path' @:: Lens' GeneratedCodeInfo'Annotation [Data.Int.Int32]@+         * 'Proto.Google.Protobuf.Descriptor_Fields.vec'path' @:: Lens' GeneratedCodeInfo'Annotation (Data.Vector.Unboxed.Vector Data.Int.Int32)@+         * 'Proto.Google.Protobuf.Descriptor_Fields.sourceFile' @:: Lens' GeneratedCodeInfo'Annotation Data.Text.Text@+         * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'sourceFile' @:: Lens' GeneratedCodeInfo'Annotation (Prelude.Maybe Data.Text.Text)@+         * 'Proto.Google.Protobuf.Descriptor_Fields.begin' @:: Lens' GeneratedCodeInfo'Annotation Data.Int.Int32@+         * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'begin' @:: Lens' GeneratedCodeInfo'Annotation (Prelude.Maybe Data.Int.Int32)@+         * 'Proto.Google.Protobuf.Descriptor_Fields.end' @:: Lens' GeneratedCodeInfo'Annotation Data.Int.Int32@+         * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'end' @:: Lens' GeneratedCodeInfo'Annotation (Prelude.Maybe Data.Int.Int32)@ -}+data GeneratedCodeInfo'Annotation+  = GeneratedCodeInfo'Annotation'_constructor {_GeneratedCodeInfo'Annotation'path :: !(Data.Vector.Unboxed.Vector Data.Int.Int32),+                                               _GeneratedCodeInfo'Annotation'sourceFile :: !(Prelude.Maybe Data.Text.Text),+                                               _GeneratedCodeInfo'Annotation'begin :: !(Prelude.Maybe Data.Int.Int32),+                                               _GeneratedCodeInfo'Annotation'end :: !(Prelude.Maybe Data.Int.Int32),+                                               _GeneratedCodeInfo'Annotation'_unknownFields :: !Data.ProtoLens.FieldSet}+  deriving (Prelude.Eq, Prelude.Ord)+instance Prelude.Show GeneratedCodeInfo'Annotation where+  showsPrec _ __x __s+    = Prelude.showChar+        '{'+        (Prelude.showString+           (Data.ProtoLens.showMessageShort __x) (Prelude.showChar '}' __s))+instance Data.ProtoLens.Field.HasField GeneratedCodeInfo'Annotation "path" [Data.Int.Int32] where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _GeneratedCodeInfo'Annotation'path+           (\ x__ y__ -> x__ {_GeneratedCodeInfo'Annotation'path = y__}))+        (Lens.Family2.Unchecked.lens+           Data.Vector.Generic.toList+           (\ _ y__ -> Data.Vector.Generic.fromList y__))+instance Data.ProtoLens.Field.HasField GeneratedCodeInfo'Annotation "vec'path" (Data.Vector.Unboxed.Vector Data.Int.Int32) where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _GeneratedCodeInfo'Annotation'path+           (\ x__ y__ -> x__ {_GeneratedCodeInfo'Annotation'path = y__}))+        Prelude.id+instance Data.ProtoLens.Field.HasField GeneratedCodeInfo'Annotation "sourceFile" Data.Text.Text where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _GeneratedCodeInfo'Annotation'sourceFile+           (\ x__ y__+              -> x__ {_GeneratedCodeInfo'Annotation'sourceFile = y__}))+        (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault)+instance Data.ProtoLens.Field.HasField GeneratedCodeInfo'Annotation "maybe'sourceFile" (Prelude.Maybe Data.Text.Text) where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _GeneratedCodeInfo'Annotation'sourceFile+           (\ x__ y__+              -> x__ {_GeneratedCodeInfo'Annotation'sourceFile = y__}))+        Prelude.id+instance Data.ProtoLens.Field.HasField GeneratedCodeInfo'Annotation "begin" Data.Int.Int32 where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _GeneratedCodeInfo'Annotation'begin+           (\ x__ y__ -> x__ {_GeneratedCodeInfo'Annotation'begin = y__}))+        (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault)+instance Data.ProtoLens.Field.HasField GeneratedCodeInfo'Annotation "maybe'begin" (Prelude.Maybe Data.Int.Int32) where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _GeneratedCodeInfo'Annotation'begin+           (\ x__ y__ -> x__ {_GeneratedCodeInfo'Annotation'begin = y__}))+        Prelude.id+instance Data.ProtoLens.Field.HasField GeneratedCodeInfo'Annotation "end" Data.Int.Int32 where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _GeneratedCodeInfo'Annotation'end+           (\ x__ y__ -> x__ {_GeneratedCodeInfo'Annotation'end = y__}))+        (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault)+instance Data.ProtoLens.Field.HasField GeneratedCodeInfo'Annotation "maybe'end" (Prelude.Maybe Data.Int.Int32) where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _GeneratedCodeInfo'Annotation'end+           (\ x__ y__ -> x__ {_GeneratedCodeInfo'Annotation'end = y__}))+        Prelude.id+instance Data.ProtoLens.Message GeneratedCodeInfo'Annotation where+  messageName _+    = Data.Text.pack "google.protobuf.GeneratedCodeInfo.Annotation"+  fieldsByTag+    = let+        path__field_descriptor+          = Data.ProtoLens.FieldDescriptor+              "path"+              (Data.ProtoLens.ScalarField Data.ProtoLens.Int32Field ::+                 Data.ProtoLens.FieldTypeDescriptor Data.Int.Int32)+              (Data.ProtoLens.RepeatedField+                 Data.ProtoLens.Packed (Data.ProtoLens.Field.field @"path")) ::+              Data.ProtoLens.FieldDescriptor GeneratedCodeInfo'Annotation+        sourceFile__field_descriptor+          = Data.ProtoLens.FieldDescriptor+              "source_file"+              (Data.ProtoLens.ScalarField Data.ProtoLens.StringField ::+                 Data.ProtoLens.FieldTypeDescriptor Data.Text.Text)+              (Data.ProtoLens.OptionalField+                 (Data.ProtoLens.Field.field @"maybe'sourceFile")) ::+              Data.ProtoLens.FieldDescriptor GeneratedCodeInfo'Annotation+        begin__field_descriptor+          = Data.ProtoLens.FieldDescriptor+              "begin"+              (Data.ProtoLens.ScalarField Data.ProtoLens.Int32Field ::+                 Data.ProtoLens.FieldTypeDescriptor Data.Int.Int32)+              (Data.ProtoLens.OptionalField+                 (Data.ProtoLens.Field.field @"maybe'begin")) ::+              Data.ProtoLens.FieldDescriptor GeneratedCodeInfo'Annotation+        end__field_descriptor+          = Data.ProtoLens.FieldDescriptor+              "end"+              (Data.ProtoLens.ScalarField Data.ProtoLens.Int32Field ::+                 Data.ProtoLens.FieldTypeDescriptor Data.Int.Int32)+              (Data.ProtoLens.OptionalField+                 (Data.ProtoLens.Field.field @"maybe'end")) ::+              Data.ProtoLens.FieldDescriptor GeneratedCodeInfo'Annotation+      in+        Data.Map.fromList+          [(Data.ProtoLens.Tag 1, path__field_descriptor),+           (Data.ProtoLens.Tag 2, sourceFile__field_descriptor),+           (Data.ProtoLens.Tag 3, begin__field_descriptor),+           (Data.ProtoLens.Tag 4, end__field_descriptor)]+  unknownFields+    = Lens.Family2.Unchecked.lens+        _GeneratedCodeInfo'Annotation'_unknownFields+        (\ x__ y__+           -> x__ {_GeneratedCodeInfo'Annotation'_unknownFields = y__})+  defMessage+    = GeneratedCodeInfo'Annotation'_constructor+        {_GeneratedCodeInfo'Annotation'path = Data.Vector.Generic.empty,+         _GeneratedCodeInfo'Annotation'sourceFile = Prelude.Nothing,+         _GeneratedCodeInfo'Annotation'begin = Prelude.Nothing,+         _GeneratedCodeInfo'Annotation'end = Prelude.Nothing,+         _GeneratedCodeInfo'Annotation'_unknownFields = []}+  parseMessage+    = let+        loop ::+          GeneratedCodeInfo'Annotation+          -> Data.ProtoLens.Encoding.Growing.Growing Data.Vector.Unboxed.Vector Data.ProtoLens.Encoding.Growing.RealWorld Data.Int.Int32+             -> Data.ProtoLens.Encoding.Bytes.Parser GeneratedCodeInfo'Annotation+        loop x mutable'path+          = do end <- Data.ProtoLens.Encoding.Bytes.atEnd+               if end then+                   do frozen'path <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO+                                       (Data.ProtoLens.Encoding.Growing.unsafeFreeze mutable'path)+                      (let missing = []+                       in+                         if Prelude.null missing then+                             Prelude.return ()+                         else+                             Prelude.fail+                               ((Prelude.++)+                                  "Missing required fields: "+                                  (Prelude.show (missing :: [Prelude.String]))))+                      Prelude.return+                        (Lens.Family2.over+                           Data.ProtoLens.unknownFields+                           (\ !t -> Prelude.reverse t)+                           (Lens.Family2.set+                              (Data.ProtoLens.Field.field @"vec'path") frozen'path x))+               else+                   do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt+                      case tag of+                        8 -> do !y <- (Data.ProtoLens.Encoding.Bytes.<?>)+                                        (Prelude.fmap+                                           Prelude.fromIntegral+                                           Data.ProtoLens.Encoding.Bytes.getVarInt)+                                        "path"+                                v <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO+                                       (Data.ProtoLens.Encoding.Growing.append mutable'path y)+                                loop x v+                        10+                          -> do y <- do len <- Data.ProtoLens.Encoding.Bytes.getVarInt+                                        Data.ProtoLens.Encoding.Bytes.isolate+                                          (Prelude.fromIntegral len)+                                          ((let+                                              ploop qs+                                                = do packedEnd <- Data.ProtoLens.Encoding.Bytes.atEnd+                                                     if packedEnd then+                                                         Prelude.return qs+                                                     else+                                                         do !q <- (Data.ProtoLens.Encoding.Bytes.<?>)+                                                                    (Prelude.fmap+                                                                       Prelude.fromIntegral+                                                                       Data.ProtoLens.Encoding.Bytes.getVarInt)+                                                                    "path"+                                                            qs' <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO+                                                                     (Data.ProtoLens.Encoding.Growing.append+                                                                        qs q)+                                                            ploop qs'+                                            in ploop)+                                             mutable'path)+                                loop x y+                        18+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)+                                       (do value <- do len <- Data.ProtoLens.Encoding.Bytes.getVarInt+                                                       Data.ProtoLens.Encoding.Bytes.getBytes+                                                         (Prelude.fromIntegral len)+                                           Data.ProtoLens.Encoding.Bytes.runEither+                                             (case Data.Text.Encoding.decodeUtf8' value of+                                                (Prelude.Left err)+                                                  -> Prelude.Left (Prelude.show err)+                                                (Prelude.Right r) -> Prelude.Right r))+                                       "source_file"+                                loop+                                  (Lens.Family2.set (Data.ProtoLens.Field.field @"sourceFile") y x)+                                  mutable'path+                        24+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)+                                       (Prelude.fmap+                                          Prelude.fromIntegral+                                          Data.ProtoLens.Encoding.Bytes.getVarInt)+                                       "begin"+                                loop+                                  (Lens.Family2.set (Data.ProtoLens.Field.field @"begin") y x)+                                  mutable'path+                        32+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)+                                       (Prelude.fmap+                                          Prelude.fromIntegral+                                          Data.ProtoLens.Encoding.Bytes.getVarInt)+                                       "end"+                                loop+                                  (Lens.Family2.set (Data.ProtoLens.Field.field @"end") y x)+                                  mutable'path+                        wire+                          -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire+                                        wire+                                loop+                                  (Lens.Family2.over+                                     Data.ProtoLens.unknownFields (\ !t -> (:) y t) x)+                                  mutable'path+      in+        (Data.ProtoLens.Encoding.Bytes.<?>)+          (do mutable'path <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO+                                Data.ProtoLens.Encoding.Growing.new+              loop Data.ProtoLens.defMessage mutable'path)+          "Annotation"+  buildMessage+    = \ _x+        -> (Data.Monoid.<>)+             (let+                p = Lens.Family2.view (Data.ProtoLens.Field.field @"vec'path") _x+              in+                if Data.Vector.Generic.null p then+                    Data.Monoid.mempty+                else+                    (Data.Monoid.<>)+                      (Data.ProtoLens.Encoding.Bytes.putVarInt 10)+                      ((\ bs+                          -> (Data.Monoid.<>)+                               (Data.ProtoLens.Encoding.Bytes.putVarInt+                                  (Prelude.fromIntegral (Data.ByteString.length bs)))+                               (Data.ProtoLens.Encoding.Bytes.putBytes bs))+                         (Data.ProtoLens.Encoding.Bytes.runBuilder+                            (Data.ProtoLens.Encoding.Bytes.foldMapBuilder+                               ((Prelude..)+                                  Data.ProtoLens.Encoding.Bytes.putVarInt Prelude.fromIntegral)+                               p))))+             ((Data.Monoid.<>)+                (case+                     Lens.Family2.view+                       (Data.ProtoLens.Field.field @"maybe'sourceFile") _x+                 of+                   Prelude.Nothing -> Data.Monoid.mempty+                   (Prelude.Just _v)+                     -> (Data.Monoid.<>)+                          (Data.ProtoLens.Encoding.Bytes.putVarInt 18)+                          ((Prelude..)+                             (\ bs+                                -> (Data.Monoid.<>)+                                     (Data.ProtoLens.Encoding.Bytes.putVarInt+                                        (Prelude.fromIntegral (Data.ByteString.length bs)))+                                     (Data.ProtoLens.Encoding.Bytes.putBytes bs))+                             Data.Text.Encoding.encodeUtf8+                             _v))+                ((Data.Monoid.<>)+                   (case+                        Lens.Family2.view (Data.ProtoLens.Field.field @"maybe'begin") _x+                    of+                      Prelude.Nothing -> Data.Monoid.mempty+                      (Prelude.Just _v)+                        -> (Data.Monoid.<>)+                             (Data.ProtoLens.Encoding.Bytes.putVarInt 24)+                             ((Prelude..)+                                Data.ProtoLens.Encoding.Bytes.putVarInt Prelude.fromIntegral _v))+                   ((Data.Monoid.<>)+                      (case+                           Lens.Family2.view (Data.ProtoLens.Field.field @"maybe'end") _x+                       of+                         Prelude.Nothing -> Data.Monoid.mempty+                         (Prelude.Just _v)+                           -> (Data.Monoid.<>)+                                (Data.ProtoLens.Encoding.Bytes.putVarInt 32)+                                ((Prelude..)+                                   Data.ProtoLens.Encoding.Bytes.putVarInt Prelude.fromIntegral _v))+                      (Data.ProtoLens.Encoding.Wire.buildFieldSet+                         (Lens.Family2.view Data.ProtoLens.unknownFields _x)))))+instance Control.DeepSeq.NFData GeneratedCodeInfo'Annotation where+  rnf+    = \ x__+        -> Control.DeepSeq.deepseq+             (_GeneratedCodeInfo'Annotation'_unknownFields x__)+             (Control.DeepSeq.deepseq+                (_GeneratedCodeInfo'Annotation'path x__)+                (Control.DeepSeq.deepseq+                   (_GeneratedCodeInfo'Annotation'sourceFile x__)+                   (Control.DeepSeq.deepseq+                      (_GeneratedCodeInfo'Annotation'begin x__)+                      (Control.DeepSeq.deepseq+                         (_GeneratedCodeInfo'Annotation'end x__) ()))))+{- | Fields :+     +         * 'Proto.Google.Protobuf.Descriptor_Fields.messageSetWireFormat' @:: Lens' MessageOptions Prelude.Bool@+         * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'messageSetWireFormat' @:: Lens' MessageOptions (Prelude.Maybe Prelude.Bool)@+         * 'Proto.Google.Protobuf.Descriptor_Fields.noStandardDescriptorAccessor' @:: Lens' MessageOptions Prelude.Bool@+         * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'noStandardDescriptorAccessor' @:: Lens' MessageOptions (Prelude.Maybe Prelude.Bool)@+         * 'Proto.Google.Protobuf.Descriptor_Fields.deprecated' @:: Lens' MessageOptions Prelude.Bool@+         * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'deprecated' @:: Lens' MessageOptions (Prelude.Maybe Prelude.Bool)@+         * 'Proto.Google.Protobuf.Descriptor_Fields.mapEntry' @:: Lens' MessageOptions Prelude.Bool@+         * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'mapEntry' @:: Lens' MessageOptions (Prelude.Maybe Prelude.Bool)@+         * 'Proto.Google.Protobuf.Descriptor_Fields.uninterpretedOption' @:: Lens' MessageOptions [UninterpretedOption]@+         * 'Proto.Google.Protobuf.Descriptor_Fields.vec'uninterpretedOption' @:: Lens' MessageOptions (Data.Vector.Vector UninterpretedOption)@ -}+data MessageOptions+  = MessageOptions'_constructor {_MessageOptions'messageSetWireFormat :: !(Prelude.Maybe Prelude.Bool),+                                 _MessageOptions'noStandardDescriptorAccessor :: !(Prelude.Maybe Prelude.Bool),+                                 _MessageOptions'deprecated :: !(Prelude.Maybe Prelude.Bool),+                                 _MessageOptions'mapEntry :: !(Prelude.Maybe Prelude.Bool),+                                 _MessageOptions'uninterpretedOption :: !(Data.Vector.Vector UninterpretedOption),+                                 _MessageOptions'_unknownFields :: !Data.ProtoLens.FieldSet}+  deriving (Prelude.Eq, Prelude.Ord)+instance Prelude.Show MessageOptions where+  showsPrec _ __x __s+    = Prelude.showChar+        '{'+        (Prelude.showString+           (Data.ProtoLens.showMessageShort __x) (Prelude.showChar '}' __s))+instance Data.ProtoLens.Field.HasField MessageOptions "messageSetWireFormat" Prelude.Bool where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _MessageOptions'messageSetWireFormat+           (\ x__ y__ -> x__ {_MessageOptions'messageSetWireFormat = y__}))+        (Data.ProtoLens.maybeLens Prelude.False)+instance Data.ProtoLens.Field.HasField MessageOptions "maybe'messageSetWireFormat" (Prelude.Maybe Prelude.Bool) where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _MessageOptions'messageSetWireFormat+           (\ x__ y__ -> x__ {_MessageOptions'messageSetWireFormat = y__}))+        Prelude.id+instance Data.ProtoLens.Field.HasField MessageOptions "noStandardDescriptorAccessor" Prelude.Bool where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _MessageOptions'noStandardDescriptorAccessor+           (\ x__ y__+              -> x__ {_MessageOptions'noStandardDescriptorAccessor = y__}))+        (Data.ProtoLens.maybeLens Prelude.False)+instance Data.ProtoLens.Field.HasField MessageOptions "maybe'noStandardDescriptorAccessor" (Prelude.Maybe Prelude.Bool) where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _MessageOptions'noStandardDescriptorAccessor+           (\ x__ y__+              -> x__ {_MessageOptions'noStandardDescriptorAccessor = y__}))+        Prelude.id+instance Data.ProtoLens.Field.HasField MessageOptions "deprecated" Prelude.Bool where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _MessageOptions'deprecated+           (\ x__ y__ -> x__ {_MessageOptions'deprecated = y__}))+        (Data.ProtoLens.maybeLens Prelude.False)+instance Data.ProtoLens.Field.HasField MessageOptions "maybe'deprecated" (Prelude.Maybe Prelude.Bool) where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _MessageOptions'deprecated+           (\ x__ y__ -> x__ {_MessageOptions'deprecated = y__}))+        Prelude.id+instance Data.ProtoLens.Field.HasField MessageOptions "mapEntry" Prelude.Bool where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _MessageOptions'mapEntry+           (\ x__ y__ -> x__ {_MessageOptions'mapEntry = y__}))+        (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault)+instance Data.ProtoLens.Field.HasField MessageOptions "maybe'mapEntry" (Prelude.Maybe Prelude.Bool) where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _MessageOptions'mapEntry+           (\ x__ y__ -> x__ {_MessageOptions'mapEntry = y__}))+        Prelude.id+instance Data.ProtoLens.Field.HasField MessageOptions "uninterpretedOption" [UninterpretedOption] where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _MessageOptions'uninterpretedOption+           (\ x__ y__ -> x__ {_MessageOptions'uninterpretedOption = y__}))+        (Lens.Family2.Unchecked.lens+           Data.Vector.Generic.toList+           (\ _ y__ -> Data.Vector.Generic.fromList y__))+instance Data.ProtoLens.Field.HasField MessageOptions "vec'uninterpretedOption" (Data.Vector.Vector UninterpretedOption) where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _MessageOptions'uninterpretedOption+           (\ x__ y__ -> x__ {_MessageOptions'uninterpretedOption = y__}))+        Prelude.id+instance Data.ProtoLens.Message MessageOptions where+  messageName _ = Data.Text.pack "google.protobuf.MessageOptions"+  fieldsByTag+    = let+        messageSetWireFormat__field_descriptor+          = Data.ProtoLens.FieldDescriptor+              "message_set_wire_format"+              (Data.ProtoLens.ScalarField Data.ProtoLens.BoolField ::+                 Data.ProtoLens.FieldTypeDescriptor Prelude.Bool)+              (Data.ProtoLens.OptionalField+                 (Data.ProtoLens.Field.field @"maybe'messageSetWireFormat")) ::+              Data.ProtoLens.FieldDescriptor MessageOptions+        noStandardDescriptorAccessor__field_descriptor+          = Data.ProtoLens.FieldDescriptor+              "no_standard_descriptor_accessor"+              (Data.ProtoLens.ScalarField Data.ProtoLens.BoolField ::+                 Data.ProtoLens.FieldTypeDescriptor Prelude.Bool)+              (Data.ProtoLens.OptionalField+                 (Data.ProtoLens.Field.field+                    @"maybe'noStandardDescriptorAccessor")) ::+              Data.ProtoLens.FieldDescriptor MessageOptions+        deprecated__field_descriptor+          = Data.ProtoLens.FieldDescriptor+              "deprecated"+              (Data.ProtoLens.ScalarField Data.ProtoLens.BoolField ::+                 Data.ProtoLens.FieldTypeDescriptor Prelude.Bool)+              (Data.ProtoLens.OptionalField+                 (Data.ProtoLens.Field.field @"maybe'deprecated")) ::+              Data.ProtoLens.FieldDescriptor MessageOptions+        mapEntry__field_descriptor+          = Data.ProtoLens.FieldDescriptor+              "map_entry"+              (Data.ProtoLens.ScalarField Data.ProtoLens.BoolField ::+                 Data.ProtoLens.FieldTypeDescriptor Prelude.Bool)+              (Data.ProtoLens.OptionalField+                 (Data.ProtoLens.Field.field @"maybe'mapEntry")) ::+              Data.ProtoLens.FieldDescriptor MessageOptions+        uninterpretedOption__field_descriptor+          = Data.ProtoLens.FieldDescriptor+              "uninterpreted_option"+              (Data.ProtoLens.MessageField Data.ProtoLens.MessageType ::+                 Data.ProtoLens.FieldTypeDescriptor UninterpretedOption)+              (Data.ProtoLens.RepeatedField+                 Data.ProtoLens.Unpacked+                 (Data.ProtoLens.Field.field @"uninterpretedOption")) ::+              Data.ProtoLens.FieldDescriptor MessageOptions+      in+        Data.Map.fromList+          [(Data.ProtoLens.Tag 1, messageSetWireFormat__field_descriptor),+           (Data.ProtoLens.Tag 2, +            noStandardDescriptorAccessor__field_descriptor),+           (Data.ProtoLens.Tag 3, deprecated__field_descriptor),+           (Data.ProtoLens.Tag 7, mapEntry__field_descriptor),+           (Data.ProtoLens.Tag 999, uninterpretedOption__field_descriptor)]+  unknownFields+    = Lens.Family2.Unchecked.lens+        _MessageOptions'_unknownFields+        (\ x__ y__ -> x__ {_MessageOptions'_unknownFields = y__})+  defMessage+    = MessageOptions'_constructor+        {_MessageOptions'messageSetWireFormat = Prelude.Nothing,+         _MessageOptions'noStandardDescriptorAccessor = Prelude.Nothing,+         _MessageOptions'deprecated = Prelude.Nothing,+         _MessageOptions'mapEntry = Prelude.Nothing,+         _MessageOptions'uninterpretedOption = Data.Vector.Generic.empty,+         _MessageOptions'_unknownFields = []}+  parseMessage+    = let+        loop ::+          MessageOptions+          -> Data.ProtoLens.Encoding.Growing.Growing Data.Vector.Vector Data.ProtoLens.Encoding.Growing.RealWorld UninterpretedOption+             -> Data.ProtoLens.Encoding.Bytes.Parser MessageOptions+        loop x mutable'uninterpretedOption+          = do end <- Data.ProtoLens.Encoding.Bytes.atEnd+               if end then+                   do frozen'uninterpretedOption <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO+                                                      (Data.ProtoLens.Encoding.Growing.unsafeFreeze+                                                         mutable'uninterpretedOption)+                      (let missing = []+                       in+                         if Prelude.null missing then+                             Prelude.return ()+                         else+                             Prelude.fail+                               ((Prelude.++)+                                  "Missing required fields: "+                                  (Prelude.show (missing :: [Prelude.String]))))+                      Prelude.return+                        (Lens.Family2.over+                           Data.ProtoLens.unknownFields+                           (\ !t -> Prelude.reverse t)+                           (Lens.Family2.set+                              (Data.ProtoLens.Field.field @"vec'uninterpretedOption")+                              frozen'uninterpretedOption+                              x))+               else+                   do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt+                      case tag of+                        8 -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)+                                       (Prelude.fmap+                                          ((Prelude./=) 0) Data.ProtoLens.Encoding.Bytes.getVarInt)+                                       "message_set_wire_format"+                                loop+                                  (Lens.Family2.set+                                     (Data.ProtoLens.Field.field @"messageSetWireFormat") y x)+                                  mutable'uninterpretedOption+                        16+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)+                                       (Prelude.fmap+                                          ((Prelude./=) 0) Data.ProtoLens.Encoding.Bytes.getVarInt)+                                       "no_standard_descriptor_accessor"+                                loop+                                  (Lens.Family2.set+                                     (Data.ProtoLens.Field.field @"noStandardDescriptorAccessor")+                                     y+                                     x)+                                  mutable'uninterpretedOption+                        24+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)+                                       (Prelude.fmap+                                          ((Prelude./=) 0) Data.ProtoLens.Encoding.Bytes.getVarInt)+                                       "deprecated"+                                loop+                                  (Lens.Family2.set (Data.ProtoLens.Field.field @"deprecated") y x)+                                  mutable'uninterpretedOption+                        56+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)+                                       (Prelude.fmap+                                          ((Prelude./=) 0) Data.ProtoLens.Encoding.Bytes.getVarInt)+                                       "map_entry"+                                loop+                                  (Lens.Family2.set (Data.ProtoLens.Field.field @"mapEntry") y x)+                                  mutable'uninterpretedOption+                        7994+                          -> do !y <- (Data.ProtoLens.Encoding.Bytes.<?>)+                                        (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt+                                            Data.ProtoLens.Encoding.Bytes.isolate+                                              (Prelude.fromIntegral len)+                                              Data.ProtoLens.parseMessage)+                                        "uninterpreted_option"+                                v <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO+                                       (Data.ProtoLens.Encoding.Growing.append+                                          mutable'uninterpretedOption y)+                                loop x v+                        wire+                          -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire+                                        wire+                                loop+                                  (Lens.Family2.over+                                     Data.ProtoLens.unknownFields (\ !t -> (:) y t) x)+                                  mutable'uninterpretedOption+      in+        (Data.ProtoLens.Encoding.Bytes.<?>)+          (do mutable'uninterpretedOption <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO+                                               Data.ProtoLens.Encoding.Growing.new+              loop Data.ProtoLens.defMessage mutable'uninterpretedOption)+          "MessageOptions"+  buildMessage+    = \ _x+        -> (Data.Monoid.<>)+             (case+                  Lens.Family2.view+                    (Data.ProtoLens.Field.field @"maybe'messageSetWireFormat") _x+              of+                Prelude.Nothing -> Data.Monoid.mempty+                (Prelude.Just _v)+                  -> (Data.Monoid.<>)+                       (Data.ProtoLens.Encoding.Bytes.putVarInt 8)+                       ((Prelude..)+                          Data.ProtoLens.Encoding.Bytes.putVarInt+                          (\ b -> if b then 1 else 0)+                          _v))+             ((Data.Monoid.<>)+                (case+                     Lens.Family2.view+                       (Data.ProtoLens.Field.field @"maybe'noStandardDescriptorAccessor")+                       _x+                 of+                   Prelude.Nothing -> Data.Monoid.mempty+                   (Prelude.Just _v)+                     -> (Data.Monoid.<>)+                          (Data.ProtoLens.Encoding.Bytes.putVarInt 16)+                          ((Prelude..)+                             Data.ProtoLens.Encoding.Bytes.putVarInt+                             (\ b -> if b then 1 else 0)+                             _v))+                ((Data.Monoid.<>)+                   (case+                        Lens.Family2.view+                          (Data.ProtoLens.Field.field @"maybe'deprecated") _x+                    of+                      Prelude.Nothing -> Data.Monoid.mempty+                      (Prelude.Just _v)+                        -> (Data.Monoid.<>)+                             (Data.ProtoLens.Encoding.Bytes.putVarInt 24)+                             ((Prelude..)+                                Data.ProtoLens.Encoding.Bytes.putVarInt+                                (\ b -> if b then 1 else 0)+                                _v))+                   ((Data.Monoid.<>)+                      (case+                           Lens.Family2.view (Data.ProtoLens.Field.field @"maybe'mapEntry") _x+                       of+                         Prelude.Nothing -> Data.Monoid.mempty+                         (Prelude.Just _v)+                           -> (Data.Monoid.<>)+                                (Data.ProtoLens.Encoding.Bytes.putVarInt 56)+                                ((Prelude..)+                                   Data.ProtoLens.Encoding.Bytes.putVarInt+                                   (\ b -> if b then 1 else 0)+                                   _v))+                      ((Data.Monoid.<>)+                         (Data.ProtoLens.Encoding.Bytes.foldMapBuilder+                            (\ _v+                               -> (Data.Monoid.<>)+                                    (Data.ProtoLens.Encoding.Bytes.putVarInt 7994)+                                    ((Prelude..)+                                       (\ bs+                                          -> (Data.Monoid.<>)+                                               (Data.ProtoLens.Encoding.Bytes.putVarInt+                                                  (Prelude.fromIntegral+                                                     (Data.ByteString.length bs)))+                                               (Data.ProtoLens.Encoding.Bytes.putBytes bs))+                                       Data.ProtoLens.encodeMessage+                                       _v))+                            (Lens.Family2.view+                               (Data.ProtoLens.Field.field @"vec'uninterpretedOption") _x))+                         (Data.ProtoLens.Encoding.Wire.buildFieldSet+                            (Lens.Family2.view Data.ProtoLens.unknownFields _x))))))+instance Control.DeepSeq.NFData MessageOptions where+  rnf+    = \ x__+        -> Control.DeepSeq.deepseq+             (_MessageOptions'_unknownFields x__)+             (Control.DeepSeq.deepseq+                (_MessageOptions'messageSetWireFormat x__)+                (Control.DeepSeq.deepseq+                   (_MessageOptions'noStandardDescriptorAccessor x__)+                   (Control.DeepSeq.deepseq+                      (_MessageOptions'deprecated x__)+                      (Control.DeepSeq.deepseq+                         (_MessageOptions'mapEntry x__)+                         (Control.DeepSeq.deepseq+                            (_MessageOptions'uninterpretedOption x__) ())))))+{- | Fields :+     +         * 'Proto.Google.Protobuf.Descriptor_Fields.name' @:: Lens' MethodDescriptorProto Data.Text.Text@+         * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'name' @:: Lens' MethodDescriptorProto (Prelude.Maybe Data.Text.Text)@+         * 'Proto.Google.Protobuf.Descriptor_Fields.inputType' @:: Lens' MethodDescriptorProto Data.Text.Text@+         * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'inputType' @:: Lens' MethodDescriptorProto (Prelude.Maybe Data.Text.Text)@+         * 'Proto.Google.Protobuf.Descriptor_Fields.outputType' @:: Lens' MethodDescriptorProto Data.Text.Text@+         * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'outputType' @:: Lens' MethodDescriptorProto (Prelude.Maybe Data.Text.Text)@+         * 'Proto.Google.Protobuf.Descriptor_Fields.options' @:: Lens' MethodDescriptorProto MethodOptions@+         * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'options' @:: Lens' MethodDescriptorProto (Prelude.Maybe MethodOptions)@+         * 'Proto.Google.Protobuf.Descriptor_Fields.clientStreaming' @:: Lens' MethodDescriptorProto Prelude.Bool@+         * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'clientStreaming' @:: Lens' MethodDescriptorProto (Prelude.Maybe Prelude.Bool)@+         * 'Proto.Google.Protobuf.Descriptor_Fields.serverStreaming' @:: Lens' MethodDescriptorProto Prelude.Bool@+         * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'serverStreaming' @:: Lens' MethodDescriptorProto (Prelude.Maybe Prelude.Bool)@ -}+data MethodDescriptorProto+  = MethodDescriptorProto'_constructor {_MethodDescriptorProto'name :: !(Prelude.Maybe Data.Text.Text),+                                        _MethodDescriptorProto'inputType :: !(Prelude.Maybe Data.Text.Text),+                                        _MethodDescriptorProto'outputType :: !(Prelude.Maybe Data.Text.Text),+                                        _MethodDescriptorProto'options :: !(Prelude.Maybe MethodOptions),+                                        _MethodDescriptorProto'clientStreaming :: !(Prelude.Maybe Prelude.Bool),+                                        _MethodDescriptorProto'serverStreaming :: !(Prelude.Maybe Prelude.Bool),+                                        _MethodDescriptorProto'_unknownFields :: !Data.ProtoLens.FieldSet}+  deriving (Prelude.Eq, Prelude.Ord)+instance Prelude.Show MethodDescriptorProto where+  showsPrec _ __x __s+    = Prelude.showChar+        '{'+        (Prelude.showString+           (Data.ProtoLens.showMessageShort __x) (Prelude.showChar '}' __s))+instance Data.ProtoLens.Field.HasField MethodDescriptorProto "name" Data.Text.Text where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _MethodDescriptorProto'name+           (\ x__ y__ -> x__ {_MethodDescriptorProto'name = y__}))+        (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault)+instance Data.ProtoLens.Field.HasField MethodDescriptorProto "maybe'name" (Prelude.Maybe Data.Text.Text) where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _MethodDescriptorProto'name+           (\ x__ y__ -> x__ {_MethodDescriptorProto'name = y__}))+        Prelude.id+instance Data.ProtoLens.Field.HasField MethodDescriptorProto "inputType" Data.Text.Text where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _MethodDescriptorProto'inputType+           (\ x__ y__ -> x__ {_MethodDescriptorProto'inputType = y__}))+        (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault)+instance Data.ProtoLens.Field.HasField MethodDescriptorProto "maybe'inputType" (Prelude.Maybe Data.Text.Text) where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _MethodDescriptorProto'inputType+           (\ x__ y__ -> x__ {_MethodDescriptorProto'inputType = y__}))+        Prelude.id+instance Data.ProtoLens.Field.HasField MethodDescriptorProto "outputType" Data.Text.Text where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _MethodDescriptorProto'outputType+           (\ x__ y__ -> x__ {_MethodDescriptorProto'outputType = y__}))+        (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault)+instance Data.ProtoLens.Field.HasField MethodDescriptorProto "maybe'outputType" (Prelude.Maybe Data.Text.Text) where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _MethodDescriptorProto'outputType+           (\ x__ y__ -> x__ {_MethodDescriptorProto'outputType = y__}))+        Prelude.id+instance Data.ProtoLens.Field.HasField MethodDescriptorProto "options" MethodOptions where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _MethodDescriptorProto'options+           (\ x__ y__ -> x__ {_MethodDescriptorProto'options = y__}))+        (Data.ProtoLens.maybeLens Data.ProtoLens.defMessage)+instance Data.ProtoLens.Field.HasField MethodDescriptorProto "maybe'options" (Prelude.Maybe MethodOptions) where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _MethodDescriptorProto'options+           (\ x__ y__ -> x__ {_MethodDescriptorProto'options = y__}))+        Prelude.id+instance Data.ProtoLens.Field.HasField MethodDescriptorProto "clientStreaming" Prelude.Bool where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _MethodDescriptorProto'clientStreaming+           (\ x__ y__ -> x__ {_MethodDescriptorProto'clientStreaming = y__}))+        (Data.ProtoLens.maybeLens Prelude.False)+instance Data.ProtoLens.Field.HasField MethodDescriptorProto "maybe'clientStreaming" (Prelude.Maybe Prelude.Bool) where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _MethodDescriptorProto'clientStreaming+           (\ x__ y__ -> x__ {_MethodDescriptorProto'clientStreaming = y__}))+        Prelude.id+instance Data.ProtoLens.Field.HasField MethodDescriptorProto "serverStreaming" Prelude.Bool where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _MethodDescriptorProto'serverStreaming+           (\ x__ y__ -> x__ {_MethodDescriptorProto'serverStreaming = y__}))+        (Data.ProtoLens.maybeLens Prelude.False)+instance Data.ProtoLens.Field.HasField MethodDescriptorProto "maybe'serverStreaming" (Prelude.Maybe Prelude.Bool) where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _MethodDescriptorProto'serverStreaming+           (\ x__ y__ -> x__ {_MethodDescriptorProto'serverStreaming = y__}))+        Prelude.id+instance Data.ProtoLens.Message MethodDescriptorProto where+  messageName _+    = Data.Text.pack "google.protobuf.MethodDescriptorProto"+  fieldsByTag+    = let+        name__field_descriptor+          = Data.ProtoLens.FieldDescriptor+              "name"+              (Data.ProtoLens.ScalarField Data.ProtoLens.StringField ::+                 Data.ProtoLens.FieldTypeDescriptor Data.Text.Text)+              (Data.ProtoLens.OptionalField+                 (Data.ProtoLens.Field.field @"maybe'name")) ::+              Data.ProtoLens.FieldDescriptor MethodDescriptorProto+        inputType__field_descriptor+          = Data.ProtoLens.FieldDescriptor+              "input_type"+              (Data.ProtoLens.ScalarField Data.ProtoLens.StringField ::+                 Data.ProtoLens.FieldTypeDescriptor Data.Text.Text)+              (Data.ProtoLens.OptionalField+                 (Data.ProtoLens.Field.field @"maybe'inputType")) ::+              Data.ProtoLens.FieldDescriptor MethodDescriptorProto+        outputType__field_descriptor+          = Data.ProtoLens.FieldDescriptor+              "output_type"+              (Data.ProtoLens.ScalarField Data.ProtoLens.StringField ::+                 Data.ProtoLens.FieldTypeDescriptor Data.Text.Text)+              (Data.ProtoLens.OptionalField+                 (Data.ProtoLens.Field.field @"maybe'outputType")) ::+              Data.ProtoLens.FieldDescriptor MethodDescriptorProto+        options__field_descriptor+          = Data.ProtoLens.FieldDescriptor+              "options"+              (Data.ProtoLens.MessageField Data.ProtoLens.MessageType ::+                 Data.ProtoLens.FieldTypeDescriptor MethodOptions)+              (Data.ProtoLens.OptionalField+                 (Data.ProtoLens.Field.field @"maybe'options")) ::+              Data.ProtoLens.FieldDescriptor MethodDescriptorProto+        clientStreaming__field_descriptor+          = Data.ProtoLens.FieldDescriptor+              "client_streaming"+              (Data.ProtoLens.ScalarField Data.ProtoLens.BoolField ::+                 Data.ProtoLens.FieldTypeDescriptor Prelude.Bool)+              (Data.ProtoLens.OptionalField+                 (Data.ProtoLens.Field.field @"maybe'clientStreaming")) ::+              Data.ProtoLens.FieldDescriptor MethodDescriptorProto+        serverStreaming__field_descriptor+          = Data.ProtoLens.FieldDescriptor+              "server_streaming"+              (Data.ProtoLens.ScalarField Data.ProtoLens.BoolField ::+                 Data.ProtoLens.FieldTypeDescriptor Prelude.Bool)+              (Data.ProtoLens.OptionalField+                 (Data.ProtoLens.Field.field @"maybe'serverStreaming")) ::+              Data.ProtoLens.FieldDescriptor MethodDescriptorProto+      in+        Data.Map.fromList+          [(Data.ProtoLens.Tag 1, name__field_descriptor),+           (Data.ProtoLens.Tag 2, inputType__field_descriptor),+           (Data.ProtoLens.Tag 3, outputType__field_descriptor),+           (Data.ProtoLens.Tag 4, options__field_descriptor),+           (Data.ProtoLens.Tag 5, clientStreaming__field_descriptor),+           (Data.ProtoLens.Tag 6, serverStreaming__field_descriptor)]+  unknownFields+    = Lens.Family2.Unchecked.lens+        _MethodDescriptorProto'_unknownFields+        (\ x__ y__ -> x__ {_MethodDescriptorProto'_unknownFields = y__})+  defMessage+    = MethodDescriptorProto'_constructor+        {_MethodDescriptorProto'name = Prelude.Nothing,+         _MethodDescriptorProto'inputType = Prelude.Nothing,+         _MethodDescriptorProto'outputType = Prelude.Nothing,+         _MethodDescriptorProto'options = Prelude.Nothing,+         _MethodDescriptorProto'clientStreaming = Prelude.Nothing,+         _MethodDescriptorProto'serverStreaming = Prelude.Nothing,+         _MethodDescriptorProto'_unknownFields = []}+  parseMessage+    = let+        loop ::+          MethodDescriptorProto+          -> Data.ProtoLens.Encoding.Bytes.Parser MethodDescriptorProto+        loop x+          = do end <- Data.ProtoLens.Encoding.Bytes.atEnd+               if end then+                   do (let missing = []+                       in+                         if Prelude.null missing then+                             Prelude.return ()+                         else+                             Prelude.fail+                               ((Prelude.++)+                                  "Missing required fields: "+                                  (Prelude.show (missing :: [Prelude.String]))))+                      Prelude.return+                        (Lens.Family2.over+                           Data.ProtoLens.unknownFields (\ !t -> Prelude.reverse t) x)+               else+                   do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt+                      case tag of+                        10+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)+                                       (do value <- do len <- Data.ProtoLens.Encoding.Bytes.getVarInt+                                                       Data.ProtoLens.Encoding.Bytes.getBytes+                                                         (Prelude.fromIntegral len)+                                           Data.ProtoLens.Encoding.Bytes.runEither+                                             (case Data.Text.Encoding.decodeUtf8' value of+                                                (Prelude.Left err)+                                                  -> Prelude.Left (Prelude.show err)+                                                (Prelude.Right r) -> Prelude.Right r))+                                       "name"+                                loop (Lens.Family2.set (Data.ProtoLens.Field.field @"name") y x)+                        18+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)+                                       (do value <- do len <- Data.ProtoLens.Encoding.Bytes.getVarInt+                                                       Data.ProtoLens.Encoding.Bytes.getBytes+                                                         (Prelude.fromIntegral len)+                                           Data.ProtoLens.Encoding.Bytes.runEither+                                             (case Data.Text.Encoding.decodeUtf8' value of+                                                (Prelude.Left err)+                                                  -> Prelude.Left (Prelude.show err)+                                                (Prelude.Right r) -> Prelude.Right r))+                                       "input_type"+                                loop+                                  (Lens.Family2.set (Data.ProtoLens.Field.field @"inputType") y x)+                        26+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)+                                       (do value <- do len <- Data.ProtoLens.Encoding.Bytes.getVarInt+                                                       Data.ProtoLens.Encoding.Bytes.getBytes+                                                         (Prelude.fromIntegral len)+                                           Data.ProtoLens.Encoding.Bytes.runEither+                                             (case Data.Text.Encoding.decodeUtf8' value of+                                                (Prelude.Left err)+                                                  -> Prelude.Left (Prelude.show err)+                                                (Prelude.Right r) -> Prelude.Right r))+                                       "output_type"+                                loop+                                  (Lens.Family2.set (Data.ProtoLens.Field.field @"outputType") y x)+                        34+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)+                                       (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt+                                           Data.ProtoLens.Encoding.Bytes.isolate+                                             (Prelude.fromIntegral len) Data.ProtoLens.parseMessage)+                                       "options"+                                loop (Lens.Family2.set (Data.ProtoLens.Field.field @"options") y x)+                        40+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)+                                       (Prelude.fmap+                                          ((Prelude./=) 0) Data.ProtoLens.Encoding.Bytes.getVarInt)+                                       "client_streaming"+                                loop+                                  (Lens.Family2.set+                                     (Data.ProtoLens.Field.field @"clientStreaming") y x)+                        48+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)+                                       (Prelude.fmap+                                          ((Prelude./=) 0) Data.ProtoLens.Encoding.Bytes.getVarInt)+                                       "server_streaming"+                                loop+                                  (Lens.Family2.set+                                     (Data.ProtoLens.Field.field @"serverStreaming") y x)+                        wire+                          -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire+                                        wire+                                loop+                                  (Lens.Family2.over+                                     Data.ProtoLens.unknownFields (\ !t -> (:) y t) x)+      in+        (Data.ProtoLens.Encoding.Bytes.<?>)+          (do loop Data.ProtoLens.defMessage) "MethodDescriptorProto"+  buildMessage+    = \ _x+        -> (Data.Monoid.<>)+             (case+                  Lens.Family2.view (Data.ProtoLens.Field.field @"maybe'name") _x+              of+                Prelude.Nothing -> Data.Monoid.mempty+                (Prelude.Just _v)+                  -> (Data.Monoid.<>)+                       (Data.ProtoLens.Encoding.Bytes.putVarInt 10)+                       ((Prelude..)+                          (\ bs+                             -> (Data.Monoid.<>)+                                  (Data.ProtoLens.Encoding.Bytes.putVarInt+                                     (Prelude.fromIntegral (Data.ByteString.length bs)))+                                  (Data.ProtoLens.Encoding.Bytes.putBytes bs))+                          Data.Text.Encoding.encodeUtf8+                          _v))+             ((Data.Monoid.<>)+                (case+                     Lens.Family2.view+                       (Data.ProtoLens.Field.field @"maybe'inputType") _x+                 of+                   Prelude.Nothing -> Data.Monoid.mempty+                   (Prelude.Just _v)+                     -> (Data.Monoid.<>)+                          (Data.ProtoLens.Encoding.Bytes.putVarInt 18)+                          ((Prelude..)+                             (\ bs+                                -> (Data.Monoid.<>)+                                     (Data.ProtoLens.Encoding.Bytes.putVarInt+                                        (Prelude.fromIntegral (Data.ByteString.length bs)))+                                     (Data.ProtoLens.Encoding.Bytes.putBytes bs))+                             Data.Text.Encoding.encodeUtf8+                             _v))+                ((Data.Monoid.<>)+                   (case+                        Lens.Family2.view+                          (Data.ProtoLens.Field.field @"maybe'outputType") _x+                    of+                      Prelude.Nothing -> Data.Monoid.mempty+                      (Prelude.Just _v)+                        -> (Data.Monoid.<>)+                             (Data.ProtoLens.Encoding.Bytes.putVarInt 26)+                             ((Prelude..)+                                (\ bs+                                   -> (Data.Monoid.<>)+                                        (Data.ProtoLens.Encoding.Bytes.putVarInt+                                           (Prelude.fromIntegral (Data.ByteString.length bs)))+                                        (Data.ProtoLens.Encoding.Bytes.putBytes bs))+                                Data.Text.Encoding.encodeUtf8+                                _v))+                   ((Data.Monoid.<>)+                      (case+                           Lens.Family2.view (Data.ProtoLens.Field.field @"maybe'options") _x+                       of+                         Prelude.Nothing -> Data.Monoid.mempty+                         (Prelude.Just _v)+                           -> (Data.Monoid.<>)+                                (Data.ProtoLens.Encoding.Bytes.putVarInt 34)+                                ((Prelude..)+                                   (\ bs+                                      -> (Data.Monoid.<>)+                                           (Data.ProtoLens.Encoding.Bytes.putVarInt+                                              (Prelude.fromIntegral (Data.ByteString.length bs)))+                                           (Data.ProtoLens.Encoding.Bytes.putBytes bs))+                                   Data.ProtoLens.encodeMessage+                                   _v))+                      ((Data.Monoid.<>)+                         (case+                              Lens.Family2.view+                                (Data.ProtoLens.Field.field @"maybe'clientStreaming") _x+                          of+                            Prelude.Nothing -> Data.Monoid.mempty+                            (Prelude.Just _v)+                              -> (Data.Monoid.<>)+                                   (Data.ProtoLens.Encoding.Bytes.putVarInt 40)+                                   ((Prelude..)+                                      Data.ProtoLens.Encoding.Bytes.putVarInt+                                      (\ b -> if b then 1 else 0)+                                      _v))+                         ((Data.Monoid.<>)+                            (case+                                 Lens.Family2.view+                                   (Data.ProtoLens.Field.field @"maybe'serverStreaming") _x+                             of+                               Prelude.Nothing -> Data.Monoid.mempty+                               (Prelude.Just _v)+                                 -> (Data.Monoid.<>)+                                      (Data.ProtoLens.Encoding.Bytes.putVarInt 48)+                                      ((Prelude..)+                                         Data.ProtoLens.Encoding.Bytes.putVarInt+                                         (\ b -> if b then 1 else 0)+                                         _v))+                            (Data.ProtoLens.Encoding.Wire.buildFieldSet+                               (Lens.Family2.view Data.ProtoLens.unknownFields _x)))))))+instance Control.DeepSeq.NFData MethodDescriptorProto where+  rnf+    = \ x__+        -> Control.DeepSeq.deepseq+             (_MethodDescriptorProto'_unknownFields x__)+             (Control.DeepSeq.deepseq+                (_MethodDescriptorProto'name x__)+                (Control.DeepSeq.deepseq+                   (_MethodDescriptorProto'inputType x__)+                   (Control.DeepSeq.deepseq+                      (_MethodDescriptorProto'outputType x__)+                      (Control.DeepSeq.deepseq+                         (_MethodDescriptorProto'options x__)+                         (Control.DeepSeq.deepseq+                            (_MethodDescriptorProto'clientStreaming x__)+                            (Control.DeepSeq.deepseq+                               (_MethodDescriptorProto'serverStreaming x__) ()))))))+{- | Fields :+     +         * 'Proto.Google.Protobuf.Descriptor_Fields.deprecated' @:: Lens' MethodOptions Prelude.Bool@+         * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'deprecated' @:: Lens' MethodOptions (Prelude.Maybe Prelude.Bool)@+         * 'Proto.Google.Protobuf.Descriptor_Fields.idempotencyLevel' @:: Lens' MethodOptions MethodOptions'IdempotencyLevel@+         * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'idempotencyLevel' @:: Lens' MethodOptions (Prelude.Maybe MethodOptions'IdempotencyLevel)@+         * 'Proto.Google.Protobuf.Descriptor_Fields.uninterpretedOption' @:: Lens' MethodOptions [UninterpretedOption]@+         * 'Proto.Google.Protobuf.Descriptor_Fields.vec'uninterpretedOption' @:: Lens' MethodOptions (Data.Vector.Vector UninterpretedOption)@ -}+data MethodOptions+  = MethodOptions'_constructor {_MethodOptions'deprecated :: !(Prelude.Maybe Prelude.Bool),+                                _MethodOptions'idempotencyLevel :: !(Prelude.Maybe MethodOptions'IdempotencyLevel),+                                _MethodOptions'uninterpretedOption :: !(Data.Vector.Vector UninterpretedOption),+                                _MethodOptions'_unknownFields :: !Data.ProtoLens.FieldSet}+  deriving (Prelude.Eq, Prelude.Ord)+instance Prelude.Show MethodOptions where+  showsPrec _ __x __s+    = Prelude.showChar+        '{'+        (Prelude.showString+           (Data.ProtoLens.showMessageShort __x) (Prelude.showChar '}' __s))+instance Data.ProtoLens.Field.HasField MethodOptions "deprecated" Prelude.Bool where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _MethodOptions'deprecated+           (\ x__ y__ -> x__ {_MethodOptions'deprecated = y__}))+        (Data.ProtoLens.maybeLens Prelude.False)+instance Data.ProtoLens.Field.HasField MethodOptions "maybe'deprecated" (Prelude.Maybe Prelude.Bool) where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _MethodOptions'deprecated+           (\ x__ y__ -> x__ {_MethodOptions'deprecated = y__}))+        Prelude.id+instance Data.ProtoLens.Field.HasField MethodOptions "idempotencyLevel" MethodOptions'IdempotencyLevel where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _MethodOptions'idempotencyLevel+           (\ x__ y__ -> x__ {_MethodOptions'idempotencyLevel = y__}))+        (Data.ProtoLens.maybeLens MethodOptions'IDEMPOTENCY_UNKNOWN)+instance Data.ProtoLens.Field.HasField MethodOptions "maybe'idempotencyLevel" (Prelude.Maybe MethodOptions'IdempotencyLevel) where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _MethodOptions'idempotencyLevel+           (\ x__ y__ -> x__ {_MethodOptions'idempotencyLevel = y__}))+        Prelude.id+instance Data.ProtoLens.Field.HasField MethodOptions "uninterpretedOption" [UninterpretedOption] where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _MethodOptions'uninterpretedOption+           (\ x__ y__ -> x__ {_MethodOptions'uninterpretedOption = y__}))+        (Lens.Family2.Unchecked.lens+           Data.Vector.Generic.toList+           (\ _ y__ -> Data.Vector.Generic.fromList y__))+instance Data.ProtoLens.Field.HasField MethodOptions "vec'uninterpretedOption" (Data.Vector.Vector UninterpretedOption) where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _MethodOptions'uninterpretedOption+           (\ x__ y__ -> x__ {_MethodOptions'uninterpretedOption = y__}))+        Prelude.id+instance Data.ProtoLens.Message MethodOptions where+  messageName _ = Data.Text.pack "google.protobuf.MethodOptions"+  fieldsByTag+    = let+        deprecated__field_descriptor+          = Data.ProtoLens.FieldDescriptor+              "deprecated"+              (Data.ProtoLens.ScalarField Data.ProtoLens.BoolField ::+                 Data.ProtoLens.FieldTypeDescriptor Prelude.Bool)+              (Data.ProtoLens.OptionalField+                 (Data.ProtoLens.Field.field @"maybe'deprecated")) ::+              Data.ProtoLens.FieldDescriptor MethodOptions+        idempotencyLevel__field_descriptor+          = Data.ProtoLens.FieldDescriptor+              "idempotency_level"+              (Data.ProtoLens.ScalarField Data.ProtoLens.EnumField ::+                 Data.ProtoLens.FieldTypeDescriptor MethodOptions'IdempotencyLevel)+              (Data.ProtoLens.OptionalField+                 (Data.ProtoLens.Field.field @"maybe'idempotencyLevel")) ::+              Data.ProtoLens.FieldDescriptor MethodOptions+        uninterpretedOption__field_descriptor+          = Data.ProtoLens.FieldDescriptor+              "uninterpreted_option"+              (Data.ProtoLens.MessageField Data.ProtoLens.MessageType ::+                 Data.ProtoLens.FieldTypeDescriptor UninterpretedOption)+              (Data.ProtoLens.RepeatedField+                 Data.ProtoLens.Unpacked+                 (Data.ProtoLens.Field.field @"uninterpretedOption")) ::+              Data.ProtoLens.FieldDescriptor MethodOptions+      in+        Data.Map.fromList+          [(Data.ProtoLens.Tag 33, deprecated__field_descriptor),+           (Data.ProtoLens.Tag 34, idempotencyLevel__field_descriptor),+           (Data.ProtoLens.Tag 999, uninterpretedOption__field_descriptor)]+  unknownFields+    = Lens.Family2.Unchecked.lens+        _MethodOptions'_unknownFields+        (\ x__ y__ -> x__ {_MethodOptions'_unknownFields = y__})+  defMessage+    = MethodOptions'_constructor+        {_MethodOptions'deprecated = Prelude.Nothing,+         _MethodOptions'idempotencyLevel = Prelude.Nothing,+         _MethodOptions'uninterpretedOption = Data.Vector.Generic.empty,+         _MethodOptions'_unknownFields = []}+  parseMessage+    = let+        loop ::+          MethodOptions+          -> Data.ProtoLens.Encoding.Growing.Growing Data.Vector.Vector Data.ProtoLens.Encoding.Growing.RealWorld UninterpretedOption+             -> Data.ProtoLens.Encoding.Bytes.Parser MethodOptions+        loop x mutable'uninterpretedOption+          = do end <- Data.ProtoLens.Encoding.Bytes.atEnd+               if end then+                   do frozen'uninterpretedOption <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO+                                                      (Data.ProtoLens.Encoding.Growing.unsafeFreeze+                                                         mutable'uninterpretedOption)+                      (let missing = []+                       in+                         if Prelude.null missing then+                             Prelude.return ()+                         else+                             Prelude.fail+                               ((Prelude.++)+                                  "Missing required fields: "+                                  (Prelude.show (missing :: [Prelude.String]))))+                      Prelude.return+                        (Lens.Family2.over+                           Data.ProtoLens.unknownFields+                           (\ !t -> Prelude.reverse t)+                           (Lens.Family2.set+                              (Data.ProtoLens.Field.field @"vec'uninterpretedOption")+                              frozen'uninterpretedOption+                              x))+               else+                   do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt+                      case tag of+                        264+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)+                                       (Prelude.fmap+                                          ((Prelude./=) 0) Data.ProtoLens.Encoding.Bytes.getVarInt)+                                       "deprecated"+                                loop+                                  (Lens.Family2.set (Data.ProtoLens.Field.field @"deprecated") y x)+                                  mutable'uninterpretedOption+                        272+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)+                                       (Prelude.fmap+                                          Prelude.toEnum+                                          (Prelude.fmap+                                             Prelude.fromIntegral+                                             Data.ProtoLens.Encoding.Bytes.getVarInt))+                                       "idempotency_level"+                                loop+                                  (Lens.Family2.set+                                     (Data.ProtoLens.Field.field @"idempotencyLevel") y x)+                                  mutable'uninterpretedOption+                        7994+                          -> do !y <- (Data.ProtoLens.Encoding.Bytes.<?>)+                                        (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt+                                            Data.ProtoLens.Encoding.Bytes.isolate+                                              (Prelude.fromIntegral len)+                                              Data.ProtoLens.parseMessage)+                                        "uninterpreted_option"+                                v <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO+                                       (Data.ProtoLens.Encoding.Growing.append+                                          mutable'uninterpretedOption y)+                                loop x v+                        wire+                          -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire+                                        wire+                                loop+                                  (Lens.Family2.over+                                     Data.ProtoLens.unknownFields (\ !t -> (:) y t) x)+                                  mutable'uninterpretedOption+      in+        (Data.ProtoLens.Encoding.Bytes.<?>)+          (do mutable'uninterpretedOption <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO+                                               Data.ProtoLens.Encoding.Growing.new+              loop Data.ProtoLens.defMessage mutable'uninterpretedOption)+          "MethodOptions"+  buildMessage+    = \ _x+        -> (Data.Monoid.<>)+             (case+                  Lens.Family2.view+                    (Data.ProtoLens.Field.field @"maybe'deprecated") _x+              of+                Prelude.Nothing -> Data.Monoid.mempty+                (Prelude.Just _v)+                  -> (Data.Monoid.<>)+                       (Data.ProtoLens.Encoding.Bytes.putVarInt 264)+                       ((Prelude..)+                          Data.ProtoLens.Encoding.Bytes.putVarInt+                          (\ b -> if b then 1 else 0)+                          _v))+             ((Data.Monoid.<>)+                (case+                     Lens.Family2.view+                       (Data.ProtoLens.Field.field @"maybe'idempotencyLevel") _x+                 of+                   Prelude.Nothing -> Data.Monoid.mempty+                   (Prelude.Just _v)+                     -> (Data.Monoid.<>)+                          (Data.ProtoLens.Encoding.Bytes.putVarInt 272)+                          ((Prelude..)+                             ((Prelude..)+                                Data.ProtoLens.Encoding.Bytes.putVarInt Prelude.fromIntegral)+                             Prelude.fromEnum+                             _v))+                ((Data.Monoid.<>)+                   (Data.ProtoLens.Encoding.Bytes.foldMapBuilder+                      (\ _v+                         -> (Data.Monoid.<>)+                              (Data.ProtoLens.Encoding.Bytes.putVarInt 7994)+                              ((Prelude..)+                                 (\ bs+                                    -> (Data.Monoid.<>)+                                         (Data.ProtoLens.Encoding.Bytes.putVarInt+                                            (Prelude.fromIntegral (Data.ByteString.length bs)))+                                         (Data.ProtoLens.Encoding.Bytes.putBytes bs))+                                 Data.ProtoLens.encodeMessage+                                 _v))+                      (Lens.Family2.view+                         (Data.ProtoLens.Field.field @"vec'uninterpretedOption") _x))+                   (Data.ProtoLens.Encoding.Wire.buildFieldSet+                      (Lens.Family2.view Data.ProtoLens.unknownFields _x))))+instance Control.DeepSeq.NFData MethodOptions where+  rnf+    = \ x__+        -> Control.DeepSeq.deepseq+             (_MethodOptions'_unknownFields x__)+             (Control.DeepSeq.deepseq+                (_MethodOptions'deprecated x__)+                (Control.DeepSeq.deepseq+                   (_MethodOptions'idempotencyLevel x__)+                   (Control.DeepSeq.deepseq+                      (_MethodOptions'uninterpretedOption x__) ())))+data MethodOptions'IdempotencyLevel+  = MethodOptions'IDEMPOTENCY_UNKNOWN |+    MethodOptions'NO_SIDE_EFFECTS |+    MethodOptions'IDEMPOTENT+  deriving (Prelude.Show, Prelude.Eq, Prelude.Ord)+instance Data.ProtoLens.MessageEnum MethodOptions'IdempotencyLevel where+  maybeToEnum 0 = Prelude.Just MethodOptions'IDEMPOTENCY_UNKNOWN+  maybeToEnum 1 = Prelude.Just MethodOptions'NO_SIDE_EFFECTS+  maybeToEnum 2 = Prelude.Just MethodOptions'IDEMPOTENT+  maybeToEnum _ = Prelude.Nothing+  showEnum MethodOptions'IDEMPOTENCY_UNKNOWN = "IDEMPOTENCY_UNKNOWN"+  showEnum MethodOptions'NO_SIDE_EFFECTS = "NO_SIDE_EFFECTS"+  showEnum MethodOptions'IDEMPOTENT = "IDEMPOTENT"+  readEnum k+    | (Prelude.==) k "IDEMPOTENCY_UNKNOWN"+    = Prelude.Just MethodOptions'IDEMPOTENCY_UNKNOWN+    | (Prelude.==) k "NO_SIDE_EFFECTS"+    = Prelude.Just MethodOptions'NO_SIDE_EFFECTS+    | (Prelude.==) k "IDEMPOTENT"+    = Prelude.Just MethodOptions'IDEMPOTENT+    | Prelude.otherwise+    = (Prelude.>>=) (Text.Read.readMaybe k) Data.ProtoLens.maybeToEnum+instance Prelude.Bounded MethodOptions'IdempotencyLevel where+  minBound = MethodOptions'IDEMPOTENCY_UNKNOWN+  maxBound = MethodOptions'IDEMPOTENT+instance Prelude.Enum MethodOptions'IdempotencyLevel where+  toEnum k__+    = Prelude.maybe+        (Prelude.error+           ((Prelude.++)+              "toEnum: unknown value for enum IdempotencyLevel: "+              (Prelude.show k__)))+        Prelude.id+        (Data.ProtoLens.maybeToEnum k__)+  fromEnum MethodOptions'IDEMPOTENCY_UNKNOWN = 0+  fromEnum MethodOptions'NO_SIDE_EFFECTS = 1+  fromEnum MethodOptions'IDEMPOTENT = 2+  succ MethodOptions'IDEMPOTENT+    = Prelude.error+        "MethodOptions'IdempotencyLevel.succ: bad argument MethodOptions'IDEMPOTENT. This value would be out of bounds."+  succ MethodOptions'IDEMPOTENCY_UNKNOWN+    = MethodOptions'NO_SIDE_EFFECTS+  succ MethodOptions'NO_SIDE_EFFECTS = MethodOptions'IDEMPOTENT+  pred MethodOptions'IDEMPOTENCY_UNKNOWN+    = Prelude.error+        "MethodOptions'IdempotencyLevel.pred: bad argument MethodOptions'IDEMPOTENCY_UNKNOWN. This value would be out of bounds."+  pred MethodOptions'NO_SIDE_EFFECTS+    = MethodOptions'IDEMPOTENCY_UNKNOWN+  pred MethodOptions'IDEMPOTENT = MethodOptions'NO_SIDE_EFFECTS+  enumFrom = Data.ProtoLens.Message.Enum.messageEnumFrom+  enumFromTo = Data.ProtoLens.Message.Enum.messageEnumFromTo+  enumFromThen = Data.ProtoLens.Message.Enum.messageEnumFromThen+  enumFromThenTo = Data.ProtoLens.Message.Enum.messageEnumFromThenTo+instance Data.ProtoLens.FieldDefault MethodOptions'IdempotencyLevel where+  fieldDefault = MethodOptions'IDEMPOTENCY_UNKNOWN+instance Control.DeepSeq.NFData MethodOptions'IdempotencyLevel where+  rnf x__ = Prelude.seq x__ ()+{- | Fields :+     +         * 'Proto.Google.Protobuf.Descriptor_Fields.name' @:: Lens' OneofDescriptorProto Data.Text.Text@+         * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'name' @:: Lens' OneofDescriptorProto (Prelude.Maybe Data.Text.Text)@+         * 'Proto.Google.Protobuf.Descriptor_Fields.options' @:: Lens' OneofDescriptorProto OneofOptions@+         * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'options' @:: Lens' OneofDescriptorProto (Prelude.Maybe OneofOptions)@ -}+data OneofDescriptorProto+  = OneofDescriptorProto'_constructor {_OneofDescriptorProto'name :: !(Prelude.Maybe Data.Text.Text),+                                       _OneofDescriptorProto'options :: !(Prelude.Maybe OneofOptions),+                                       _OneofDescriptorProto'_unknownFields :: !Data.ProtoLens.FieldSet}+  deriving (Prelude.Eq, Prelude.Ord)+instance Prelude.Show OneofDescriptorProto where+  showsPrec _ __x __s+    = Prelude.showChar+        '{'+        (Prelude.showString+           (Data.ProtoLens.showMessageShort __x) (Prelude.showChar '}' __s))+instance Data.ProtoLens.Field.HasField OneofDescriptorProto "name" Data.Text.Text where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _OneofDescriptorProto'name+           (\ x__ y__ -> x__ {_OneofDescriptorProto'name = y__}))+        (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault)+instance Data.ProtoLens.Field.HasField OneofDescriptorProto "maybe'name" (Prelude.Maybe Data.Text.Text) where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _OneofDescriptorProto'name+           (\ x__ y__ -> x__ {_OneofDescriptorProto'name = y__}))+        Prelude.id+instance Data.ProtoLens.Field.HasField OneofDescriptorProto "options" OneofOptions where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _OneofDescriptorProto'options+           (\ x__ y__ -> x__ {_OneofDescriptorProto'options = y__}))+        (Data.ProtoLens.maybeLens Data.ProtoLens.defMessage)+instance Data.ProtoLens.Field.HasField OneofDescriptorProto "maybe'options" (Prelude.Maybe OneofOptions) where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _OneofDescriptorProto'options+           (\ x__ y__ -> x__ {_OneofDescriptorProto'options = y__}))+        Prelude.id+instance Data.ProtoLens.Message OneofDescriptorProto where+  messageName _+    = Data.Text.pack "google.protobuf.OneofDescriptorProto"+  fieldsByTag+    = let+        name__field_descriptor+          = Data.ProtoLens.FieldDescriptor+              "name"+              (Data.ProtoLens.ScalarField Data.ProtoLens.StringField ::+                 Data.ProtoLens.FieldTypeDescriptor Data.Text.Text)+              (Data.ProtoLens.OptionalField+                 (Data.ProtoLens.Field.field @"maybe'name")) ::+              Data.ProtoLens.FieldDescriptor OneofDescriptorProto+        options__field_descriptor+          = Data.ProtoLens.FieldDescriptor+              "options"+              (Data.ProtoLens.MessageField Data.ProtoLens.MessageType ::+                 Data.ProtoLens.FieldTypeDescriptor OneofOptions)+              (Data.ProtoLens.OptionalField+                 (Data.ProtoLens.Field.field @"maybe'options")) ::+              Data.ProtoLens.FieldDescriptor OneofDescriptorProto+      in+        Data.Map.fromList+          [(Data.ProtoLens.Tag 1, name__field_descriptor),+           (Data.ProtoLens.Tag 2, options__field_descriptor)]+  unknownFields+    = Lens.Family2.Unchecked.lens+        _OneofDescriptorProto'_unknownFields+        (\ x__ y__ -> x__ {_OneofDescriptorProto'_unknownFields = y__})+  defMessage+    = OneofDescriptorProto'_constructor+        {_OneofDescriptorProto'name = Prelude.Nothing,+         _OneofDescriptorProto'options = Prelude.Nothing,+         _OneofDescriptorProto'_unknownFields = []}+  parseMessage+    = let+        loop ::+          OneofDescriptorProto+          -> Data.ProtoLens.Encoding.Bytes.Parser OneofDescriptorProto+        loop x+          = do end <- Data.ProtoLens.Encoding.Bytes.atEnd+               if end then+                   do (let missing = []+                       in+                         if Prelude.null missing then+                             Prelude.return ()+                         else+                             Prelude.fail+                               ((Prelude.++)+                                  "Missing required fields: "+                                  (Prelude.show (missing :: [Prelude.String]))))+                      Prelude.return+                        (Lens.Family2.over+                           Data.ProtoLens.unknownFields (\ !t -> Prelude.reverse t) x)+               else+                   do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt+                      case tag of+                        10+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)+                                       (do value <- do len <- Data.ProtoLens.Encoding.Bytes.getVarInt+                                                       Data.ProtoLens.Encoding.Bytes.getBytes+                                                         (Prelude.fromIntegral len)+                                           Data.ProtoLens.Encoding.Bytes.runEither+                                             (case Data.Text.Encoding.decodeUtf8' value of+                                                (Prelude.Left err)+                                                  -> Prelude.Left (Prelude.show err)+                                                (Prelude.Right r) -> Prelude.Right r))+                                       "name"+                                loop (Lens.Family2.set (Data.ProtoLens.Field.field @"name") y x)+                        18+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)+                                       (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt+                                           Data.ProtoLens.Encoding.Bytes.isolate+                                             (Prelude.fromIntegral len) Data.ProtoLens.parseMessage)+                                       "options"+                                loop (Lens.Family2.set (Data.ProtoLens.Field.field @"options") y x)+                        wire+                          -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire+                                        wire+                                loop+                                  (Lens.Family2.over+                                     Data.ProtoLens.unknownFields (\ !t -> (:) y t) x)+      in+        (Data.ProtoLens.Encoding.Bytes.<?>)+          (do loop Data.ProtoLens.defMessage) "OneofDescriptorProto"+  buildMessage+    = \ _x+        -> (Data.Monoid.<>)+             (case+                  Lens.Family2.view (Data.ProtoLens.Field.field @"maybe'name") _x+              of+                Prelude.Nothing -> Data.Monoid.mempty+                (Prelude.Just _v)+                  -> (Data.Monoid.<>)+                       (Data.ProtoLens.Encoding.Bytes.putVarInt 10)+                       ((Prelude..)+                          (\ bs+                             -> (Data.Monoid.<>)+                                  (Data.ProtoLens.Encoding.Bytes.putVarInt+                                     (Prelude.fromIntegral (Data.ByteString.length bs)))+                                  (Data.ProtoLens.Encoding.Bytes.putBytes bs))+                          Data.Text.Encoding.encodeUtf8+                          _v))+             ((Data.Monoid.<>)+                (case+                     Lens.Family2.view (Data.ProtoLens.Field.field @"maybe'options") _x+                 of+                   Prelude.Nothing -> Data.Monoid.mempty+                   (Prelude.Just _v)+                     -> (Data.Monoid.<>)+                          (Data.ProtoLens.Encoding.Bytes.putVarInt 18)+                          ((Prelude..)+                             (\ bs+                                -> (Data.Monoid.<>)+                                     (Data.ProtoLens.Encoding.Bytes.putVarInt+                                        (Prelude.fromIntegral (Data.ByteString.length bs)))+                                     (Data.ProtoLens.Encoding.Bytes.putBytes bs))+                             Data.ProtoLens.encodeMessage+                             _v))+                (Data.ProtoLens.Encoding.Wire.buildFieldSet+                   (Lens.Family2.view Data.ProtoLens.unknownFields _x)))+instance Control.DeepSeq.NFData OneofDescriptorProto where+  rnf+    = \ x__+        -> Control.DeepSeq.deepseq+             (_OneofDescriptorProto'_unknownFields x__)+             (Control.DeepSeq.deepseq+                (_OneofDescriptorProto'name x__)+                (Control.DeepSeq.deepseq (_OneofDescriptorProto'options x__) ()))+{- | Fields :+     +         * 'Proto.Google.Protobuf.Descriptor_Fields.uninterpretedOption' @:: Lens' OneofOptions [UninterpretedOption]@+         * 'Proto.Google.Protobuf.Descriptor_Fields.vec'uninterpretedOption' @:: Lens' OneofOptions (Data.Vector.Vector UninterpretedOption)@ -}+data OneofOptions+  = OneofOptions'_constructor {_OneofOptions'uninterpretedOption :: !(Data.Vector.Vector UninterpretedOption),+                               _OneofOptions'_unknownFields :: !Data.ProtoLens.FieldSet}+  deriving (Prelude.Eq, Prelude.Ord)+instance Prelude.Show OneofOptions where+  showsPrec _ __x __s+    = Prelude.showChar+        '{'+        (Prelude.showString+           (Data.ProtoLens.showMessageShort __x) (Prelude.showChar '}' __s))+instance Data.ProtoLens.Field.HasField OneofOptions "uninterpretedOption" [UninterpretedOption] where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _OneofOptions'uninterpretedOption+           (\ x__ y__ -> x__ {_OneofOptions'uninterpretedOption = y__}))+        (Lens.Family2.Unchecked.lens+           Data.Vector.Generic.toList+           (\ _ y__ -> Data.Vector.Generic.fromList y__))+instance Data.ProtoLens.Field.HasField OneofOptions "vec'uninterpretedOption" (Data.Vector.Vector UninterpretedOption) where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _OneofOptions'uninterpretedOption+           (\ x__ y__ -> x__ {_OneofOptions'uninterpretedOption = y__}))+        Prelude.id+instance Data.ProtoLens.Message OneofOptions where+  messageName _ = Data.Text.pack "google.protobuf.OneofOptions"+  fieldsByTag+    = let+        uninterpretedOption__field_descriptor+          = Data.ProtoLens.FieldDescriptor+              "uninterpreted_option"+              (Data.ProtoLens.MessageField Data.ProtoLens.MessageType ::+                 Data.ProtoLens.FieldTypeDescriptor UninterpretedOption)+              (Data.ProtoLens.RepeatedField+                 Data.ProtoLens.Unpacked+                 (Data.ProtoLens.Field.field @"uninterpretedOption")) ::+              Data.ProtoLens.FieldDescriptor OneofOptions+      in+        Data.Map.fromList+          [(Data.ProtoLens.Tag 999, uninterpretedOption__field_descriptor)]+  unknownFields+    = Lens.Family2.Unchecked.lens+        _OneofOptions'_unknownFields+        (\ x__ y__ -> x__ {_OneofOptions'_unknownFields = y__})+  defMessage+    = OneofOptions'_constructor+        {_OneofOptions'uninterpretedOption = Data.Vector.Generic.empty,+         _OneofOptions'_unknownFields = []}+  parseMessage+    = let+        loop ::+          OneofOptions+          -> Data.ProtoLens.Encoding.Growing.Growing Data.Vector.Vector Data.ProtoLens.Encoding.Growing.RealWorld UninterpretedOption+             -> Data.ProtoLens.Encoding.Bytes.Parser OneofOptions+        loop x mutable'uninterpretedOption+          = do end <- Data.ProtoLens.Encoding.Bytes.atEnd+               if end then+                   do frozen'uninterpretedOption <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO+                                                      (Data.ProtoLens.Encoding.Growing.unsafeFreeze+                                                         mutable'uninterpretedOption)+                      (let missing = []+                       in+                         if Prelude.null missing then+                             Prelude.return ()+                         else+                             Prelude.fail+                               ((Prelude.++)+                                  "Missing required fields: "+                                  (Prelude.show (missing :: [Prelude.String]))))+                      Prelude.return+                        (Lens.Family2.over+                           Data.ProtoLens.unknownFields+                           (\ !t -> Prelude.reverse t)+                           (Lens.Family2.set+                              (Data.ProtoLens.Field.field @"vec'uninterpretedOption")+                              frozen'uninterpretedOption+                              x))+               else+                   do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt+                      case tag of+                        7994+                          -> do !y <- (Data.ProtoLens.Encoding.Bytes.<?>)+                                        (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt+                                            Data.ProtoLens.Encoding.Bytes.isolate+                                              (Prelude.fromIntegral len)+                                              Data.ProtoLens.parseMessage)+                                        "uninterpreted_option"+                                v <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO+                                       (Data.ProtoLens.Encoding.Growing.append+                                          mutable'uninterpretedOption y)+                                loop x v+                        wire+                          -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire+                                        wire+                                loop+                                  (Lens.Family2.over+                                     Data.ProtoLens.unknownFields (\ !t -> (:) y t) x)+                                  mutable'uninterpretedOption+      in+        (Data.ProtoLens.Encoding.Bytes.<?>)+          (do mutable'uninterpretedOption <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO+                                               Data.ProtoLens.Encoding.Growing.new+              loop Data.ProtoLens.defMessage mutable'uninterpretedOption)+          "OneofOptions"+  buildMessage+    = \ _x+        -> (Data.Monoid.<>)+             (Data.ProtoLens.Encoding.Bytes.foldMapBuilder+                (\ _v+                   -> (Data.Monoid.<>)+                        (Data.ProtoLens.Encoding.Bytes.putVarInt 7994)+                        ((Prelude..)+                           (\ bs+                              -> (Data.Monoid.<>)+                                   (Data.ProtoLens.Encoding.Bytes.putVarInt+                                      (Prelude.fromIntegral (Data.ByteString.length bs)))+                                   (Data.ProtoLens.Encoding.Bytes.putBytes bs))+                           Data.ProtoLens.encodeMessage+                           _v))+                (Lens.Family2.view+                   (Data.ProtoLens.Field.field @"vec'uninterpretedOption") _x))+             (Data.ProtoLens.Encoding.Wire.buildFieldSet+                (Lens.Family2.view Data.ProtoLens.unknownFields _x))+instance Control.DeepSeq.NFData OneofOptions where+  rnf+    = \ x__+        -> Control.DeepSeq.deepseq+             (_OneofOptions'_unknownFields x__)+             (Control.DeepSeq.deepseq+                (_OneofOptions'uninterpretedOption x__) ())+{- | Fields :+     +         * 'Proto.Google.Protobuf.Descriptor_Fields.name' @:: Lens' ServiceDescriptorProto Data.Text.Text@+         * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'name' @:: Lens' ServiceDescriptorProto (Prelude.Maybe Data.Text.Text)@+         * 'Proto.Google.Protobuf.Descriptor_Fields.method' @:: Lens' ServiceDescriptorProto [MethodDescriptorProto]@+         * 'Proto.Google.Protobuf.Descriptor_Fields.vec'method' @:: Lens' ServiceDescriptorProto (Data.Vector.Vector MethodDescriptorProto)@+         * 'Proto.Google.Protobuf.Descriptor_Fields.options' @:: Lens' ServiceDescriptorProto ServiceOptions@+         * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'options' @:: Lens' ServiceDescriptorProto (Prelude.Maybe ServiceOptions)@ -}+data ServiceDescriptorProto+  = ServiceDescriptorProto'_constructor {_ServiceDescriptorProto'name :: !(Prelude.Maybe Data.Text.Text),+                                         _ServiceDescriptorProto'method :: !(Data.Vector.Vector MethodDescriptorProto),+                                         _ServiceDescriptorProto'options :: !(Prelude.Maybe ServiceOptions),+                                         _ServiceDescriptorProto'_unknownFields :: !Data.ProtoLens.FieldSet}+  deriving (Prelude.Eq, Prelude.Ord)+instance Prelude.Show ServiceDescriptorProto where+  showsPrec _ __x __s+    = Prelude.showChar+        '{'+        (Prelude.showString+           (Data.ProtoLens.showMessageShort __x) (Prelude.showChar '}' __s))+instance Data.ProtoLens.Field.HasField ServiceDescriptorProto "name" Data.Text.Text where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _ServiceDescriptorProto'name+           (\ x__ y__ -> x__ {_ServiceDescriptorProto'name = y__}))+        (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault)+instance Data.ProtoLens.Field.HasField ServiceDescriptorProto "maybe'name" (Prelude.Maybe Data.Text.Text) where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _ServiceDescriptorProto'name+           (\ x__ y__ -> x__ {_ServiceDescriptorProto'name = y__}))+        Prelude.id+instance Data.ProtoLens.Field.HasField ServiceDescriptorProto "method" [MethodDescriptorProto] where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _ServiceDescriptorProto'method+           (\ x__ y__ -> x__ {_ServiceDescriptorProto'method = y__}))+        (Lens.Family2.Unchecked.lens+           Data.Vector.Generic.toList+           (\ _ y__ -> Data.Vector.Generic.fromList y__))+instance Data.ProtoLens.Field.HasField ServiceDescriptorProto "vec'method" (Data.Vector.Vector MethodDescriptorProto) where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _ServiceDescriptorProto'method+           (\ x__ y__ -> x__ {_ServiceDescriptorProto'method = y__}))+        Prelude.id+instance Data.ProtoLens.Field.HasField ServiceDescriptorProto "options" ServiceOptions where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _ServiceDescriptorProto'options+           (\ x__ y__ -> x__ {_ServiceDescriptorProto'options = y__}))+        (Data.ProtoLens.maybeLens Data.ProtoLens.defMessage)+instance Data.ProtoLens.Field.HasField ServiceDescriptorProto "maybe'options" (Prelude.Maybe ServiceOptions) where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _ServiceDescriptorProto'options+           (\ x__ y__ -> x__ {_ServiceDescriptorProto'options = y__}))+        Prelude.id+instance Data.ProtoLens.Message ServiceDescriptorProto where+  messageName _+    = Data.Text.pack "google.protobuf.ServiceDescriptorProto"+  fieldsByTag+    = let+        name__field_descriptor+          = Data.ProtoLens.FieldDescriptor+              "name"+              (Data.ProtoLens.ScalarField Data.ProtoLens.StringField ::+                 Data.ProtoLens.FieldTypeDescriptor Data.Text.Text)+              (Data.ProtoLens.OptionalField+                 (Data.ProtoLens.Field.field @"maybe'name")) ::+              Data.ProtoLens.FieldDescriptor ServiceDescriptorProto+        method__field_descriptor+          = Data.ProtoLens.FieldDescriptor+              "method"+              (Data.ProtoLens.MessageField Data.ProtoLens.MessageType ::+                 Data.ProtoLens.FieldTypeDescriptor MethodDescriptorProto)+              (Data.ProtoLens.RepeatedField+                 Data.ProtoLens.Unpacked (Data.ProtoLens.Field.field @"method")) ::+              Data.ProtoLens.FieldDescriptor ServiceDescriptorProto+        options__field_descriptor+          = Data.ProtoLens.FieldDescriptor+              "options"+              (Data.ProtoLens.MessageField Data.ProtoLens.MessageType ::+                 Data.ProtoLens.FieldTypeDescriptor ServiceOptions)+              (Data.ProtoLens.OptionalField+                 (Data.ProtoLens.Field.field @"maybe'options")) ::+              Data.ProtoLens.FieldDescriptor ServiceDescriptorProto+      in+        Data.Map.fromList+          [(Data.ProtoLens.Tag 1, name__field_descriptor),+           (Data.ProtoLens.Tag 2, method__field_descriptor),+           (Data.ProtoLens.Tag 3, options__field_descriptor)]+  unknownFields+    = Lens.Family2.Unchecked.lens+        _ServiceDescriptorProto'_unknownFields+        (\ x__ y__ -> x__ {_ServiceDescriptorProto'_unknownFields = y__})+  defMessage+    = ServiceDescriptorProto'_constructor+        {_ServiceDescriptorProto'name = Prelude.Nothing,+         _ServiceDescriptorProto'method = Data.Vector.Generic.empty,+         _ServiceDescriptorProto'options = Prelude.Nothing,+         _ServiceDescriptorProto'_unknownFields = []}+  parseMessage+    = let+        loop ::+          ServiceDescriptorProto+          -> Data.ProtoLens.Encoding.Growing.Growing Data.Vector.Vector Data.ProtoLens.Encoding.Growing.RealWorld MethodDescriptorProto+             -> Data.ProtoLens.Encoding.Bytes.Parser ServiceDescriptorProto+        loop x mutable'method+          = do end <- Data.ProtoLens.Encoding.Bytes.atEnd+               if end then+                   do frozen'method <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO+                                         (Data.ProtoLens.Encoding.Growing.unsafeFreeze+                                            mutable'method)+                      (let missing = []+                       in+                         if Prelude.null missing then+                             Prelude.return ()+                         else+                             Prelude.fail+                               ((Prelude.++)+                                  "Missing required fields: "+                                  (Prelude.show (missing :: [Prelude.String]))))+                      Prelude.return+                        (Lens.Family2.over+                           Data.ProtoLens.unknownFields+                           (\ !t -> Prelude.reverse t)+                           (Lens.Family2.set+                              (Data.ProtoLens.Field.field @"vec'method") frozen'method x))+               else+                   do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt+                      case tag of+                        10+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)+                                       (do value <- do len <- Data.ProtoLens.Encoding.Bytes.getVarInt+                                                       Data.ProtoLens.Encoding.Bytes.getBytes+                                                         (Prelude.fromIntegral len)+                                           Data.ProtoLens.Encoding.Bytes.runEither+                                             (case Data.Text.Encoding.decodeUtf8' value of+                                                (Prelude.Left err)+                                                  -> Prelude.Left (Prelude.show err)+                                                (Prelude.Right r) -> Prelude.Right r))+                                       "name"+                                loop+                                  (Lens.Family2.set (Data.ProtoLens.Field.field @"name") y x)+                                  mutable'method+                        18+                          -> do !y <- (Data.ProtoLens.Encoding.Bytes.<?>)+                                        (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt+                                            Data.ProtoLens.Encoding.Bytes.isolate+                                              (Prelude.fromIntegral len)+                                              Data.ProtoLens.parseMessage)+                                        "method"+                                v <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO+                                       (Data.ProtoLens.Encoding.Growing.append mutable'method y)+                                loop x v+                        26+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)+                                       (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt+                                           Data.ProtoLens.Encoding.Bytes.isolate+                                             (Prelude.fromIntegral len) Data.ProtoLens.parseMessage)+                                       "options"+                                loop+                                  (Lens.Family2.set (Data.ProtoLens.Field.field @"options") y x)+                                  mutable'method+                        wire+                          -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire+                                        wire+                                loop+                                  (Lens.Family2.over+                                     Data.ProtoLens.unknownFields (\ !t -> (:) y t) x)+                                  mutable'method+      in+        (Data.ProtoLens.Encoding.Bytes.<?>)+          (do mutable'method <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO+                                  Data.ProtoLens.Encoding.Growing.new+              loop Data.ProtoLens.defMessage mutable'method)+          "ServiceDescriptorProto"+  buildMessage+    = \ _x+        -> (Data.Monoid.<>)+             (case+                  Lens.Family2.view (Data.ProtoLens.Field.field @"maybe'name") _x+              of+                Prelude.Nothing -> Data.Monoid.mempty+                (Prelude.Just _v)+                  -> (Data.Monoid.<>)+                       (Data.ProtoLens.Encoding.Bytes.putVarInt 10)+                       ((Prelude..)+                          (\ bs+                             -> (Data.Monoid.<>)+                                  (Data.ProtoLens.Encoding.Bytes.putVarInt+                                     (Prelude.fromIntegral (Data.ByteString.length bs)))+                                  (Data.ProtoLens.Encoding.Bytes.putBytes bs))+                          Data.Text.Encoding.encodeUtf8+                          _v))+             ((Data.Monoid.<>)+                (Data.ProtoLens.Encoding.Bytes.foldMapBuilder+                   (\ _v+                      -> (Data.Monoid.<>)+                           (Data.ProtoLens.Encoding.Bytes.putVarInt 18)+                           ((Prelude..)+                              (\ bs+                                 -> (Data.Monoid.<>)+                                      (Data.ProtoLens.Encoding.Bytes.putVarInt+                                         (Prelude.fromIntegral (Data.ByteString.length bs)))+                                      (Data.ProtoLens.Encoding.Bytes.putBytes bs))+                              Data.ProtoLens.encodeMessage+                              _v))+                   (Lens.Family2.view (Data.ProtoLens.Field.field @"vec'method") _x))+                ((Data.Monoid.<>)+                   (case+                        Lens.Family2.view (Data.ProtoLens.Field.field @"maybe'options") _x+                    of+                      Prelude.Nothing -> Data.Monoid.mempty+                      (Prelude.Just _v)+                        -> (Data.Monoid.<>)+                             (Data.ProtoLens.Encoding.Bytes.putVarInt 26)+                             ((Prelude..)+                                (\ bs+                                   -> (Data.Monoid.<>)+                                        (Data.ProtoLens.Encoding.Bytes.putVarInt+                                           (Prelude.fromIntegral (Data.ByteString.length bs)))+                                        (Data.ProtoLens.Encoding.Bytes.putBytes bs))+                                Data.ProtoLens.encodeMessage+                                _v))+                   (Data.ProtoLens.Encoding.Wire.buildFieldSet+                      (Lens.Family2.view Data.ProtoLens.unknownFields _x))))+instance Control.DeepSeq.NFData ServiceDescriptorProto where+  rnf+    = \ x__+        -> Control.DeepSeq.deepseq+             (_ServiceDescriptorProto'_unknownFields x__)+             (Control.DeepSeq.deepseq+                (_ServiceDescriptorProto'name x__)+                (Control.DeepSeq.deepseq+                   (_ServiceDescriptorProto'method x__)+                   (Control.DeepSeq.deepseq+                      (_ServiceDescriptorProto'options x__) ())))+{- | Fields :+     +         * 'Proto.Google.Protobuf.Descriptor_Fields.deprecated' @:: Lens' ServiceOptions Prelude.Bool@+         * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'deprecated' @:: Lens' ServiceOptions (Prelude.Maybe Prelude.Bool)@+         * 'Proto.Google.Protobuf.Descriptor_Fields.uninterpretedOption' @:: Lens' ServiceOptions [UninterpretedOption]@+         * 'Proto.Google.Protobuf.Descriptor_Fields.vec'uninterpretedOption' @:: Lens' ServiceOptions (Data.Vector.Vector UninterpretedOption)@ -}+data ServiceOptions+  = ServiceOptions'_constructor {_ServiceOptions'deprecated :: !(Prelude.Maybe Prelude.Bool),+                                 _ServiceOptions'uninterpretedOption :: !(Data.Vector.Vector UninterpretedOption),+                                 _ServiceOptions'_unknownFields :: !Data.ProtoLens.FieldSet}+  deriving (Prelude.Eq, Prelude.Ord)+instance Prelude.Show ServiceOptions where+  showsPrec _ __x __s+    = Prelude.showChar+        '{'+        (Prelude.showString+           (Data.ProtoLens.showMessageShort __x) (Prelude.showChar '}' __s))+instance Data.ProtoLens.Field.HasField ServiceOptions "deprecated" Prelude.Bool where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _ServiceOptions'deprecated+           (\ x__ y__ -> x__ {_ServiceOptions'deprecated = y__}))+        (Data.ProtoLens.maybeLens Prelude.False)+instance Data.ProtoLens.Field.HasField ServiceOptions "maybe'deprecated" (Prelude.Maybe Prelude.Bool) where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _ServiceOptions'deprecated+           (\ x__ y__ -> x__ {_ServiceOptions'deprecated = y__}))+        Prelude.id+instance Data.ProtoLens.Field.HasField ServiceOptions "uninterpretedOption" [UninterpretedOption] where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _ServiceOptions'uninterpretedOption+           (\ x__ y__ -> x__ {_ServiceOptions'uninterpretedOption = y__}))+        (Lens.Family2.Unchecked.lens+           Data.Vector.Generic.toList+           (\ _ y__ -> Data.Vector.Generic.fromList y__))+instance Data.ProtoLens.Field.HasField ServiceOptions "vec'uninterpretedOption" (Data.Vector.Vector UninterpretedOption) where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _ServiceOptions'uninterpretedOption+           (\ x__ y__ -> x__ {_ServiceOptions'uninterpretedOption = y__}))+        Prelude.id+instance Data.ProtoLens.Message ServiceOptions where+  messageName _ = Data.Text.pack "google.protobuf.ServiceOptions"+  fieldsByTag+    = let+        deprecated__field_descriptor+          = Data.ProtoLens.FieldDescriptor+              "deprecated"+              (Data.ProtoLens.ScalarField Data.ProtoLens.BoolField ::+                 Data.ProtoLens.FieldTypeDescriptor Prelude.Bool)+              (Data.ProtoLens.OptionalField+                 (Data.ProtoLens.Field.field @"maybe'deprecated")) ::+              Data.ProtoLens.FieldDescriptor ServiceOptions+        uninterpretedOption__field_descriptor+          = Data.ProtoLens.FieldDescriptor+              "uninterpreted_option"+              (Data.ProtoLens.MessageField Data.ProtoLens.MessageType ::+                 Data.ProtoLens.FieldTypeDescriptor UninterpretedOption)+              (Data.ProtoLens.RepeatedField+                 Data.ProtoLens.Unpacked+                 (Data.ProtoLens.Field.field @"uninterpretedOption")) ::+              Data.ProtoLens.FieldDescriptor ServiceOptions+      in+        Data.Map.fromList+          [(Data.ProtoLens.Tag 33, deprecated__field_descriptor),+           (Data.ProtoLens.Tag 999, uninterpretedOption__field_descriptor)]+  unknownFields+    = Lens.Family2.Unchecked.lens+        _ServiceOptions'_unknownFields+        (\ x__ y__ -> x__ {_ServiceOptions'_unknownFields = y__})+  defMessage+    = ServiceOptions'_constructor+        {_ServiceOptions'deprecated = Prelude.Nothing,+         _ServiceOptions'uninterpretedOption = Data.Vector.Generic.empty,+         _ServiceOptions'_unknownFields = []}+  parseMessage+    = let+        loop ::+          ServiceOptions+          -> Data.ProtoLens.Encoding.Growing.Growing Data.Vector.Vector Data.ProtoLens.Encoding.Growing.RealWorld UninterpretedOption+             -> Data.ProtoLens.Encoding.Bytes.Parser ServiceOptions+        loop x mutable'uninterpretedOption+          = do end <- Data.ProtoLens.Encoding.Bytes.atEnd+               if end then+                   do frozen'uninterpretedOption <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO+                                                      (Data.ProtoLens.Encoding.Growing.unsafeFreeze+                                                         mutable'uninterpretedOption)+                      (let missing = []+                       in+                         if Prelude.null missing then+                             Prelude.return ()+                         else+                             Prelude.fail+                               ((Prelude.++)+                                  "Missing required fields: "+                                  (Prelude.show (missing :: [Prelude.String]))))+                      Prelude.return+                        (Lens.Family2.over+                           Data.ProtoLens.unknownFields+                           (\ !t -> Prelude.reverse t)+                           (Lens.Family2.set+                              (Data.ProtoLens.Field.field @"vec'uninterpretedOption")+                              frozen'uninterpretedOption+                              x))+               else+                   do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt+                      case tag of+                        264+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)+                                       (Prelude.fmap+                                          ((Prelude./=) 0) Data.ProtoLens.Encoding.Bytes.getVarInt)+                                       "deprecated"+                                loop+                                  (Lens.Family2.set (Data.ProtoLens.Field.field @"deprecated") y x)+                                  mutable'uninterpretedOption+                        7994+                          -> do !y <- (Data.ProtoLens.Encoding.Bytes.<?>)+                                        (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt+                                            Data.ProtoLens.Encoding.Bytes.isolate+                                              (Prelude.fromIntegral len)+                                              Data.ProtoLens.parseMessage)+                                        "uninterpreted_option"+                                v <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO+                                       (Data.ProtoLens.Encoding.Growing.append+                                          mutable'uninterpretedOption y)+                                loop x v+                        wire+                          -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire+                                        wire+                                loop+                                  (Lens.Family2.over+                                     Data.ProtoLens.unknownFields (\ !t -> (:) y t) x)+                                  mutable'uninterpretedOption+      in+        (Data.ProtoLens.Encoding.Bytes.<?>)+          (do mutable'uninterpretedOption <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO+                                               Data.ProtoLens.Encoding.Growing.new+              loop Data.ProtoLens.defMessage mutable'uninterpretedOption)+          "ServiceOptions"+  buildMessage+    = \ _x+        -> (Data.Monoid.<>)+             (case+                  Lens.Family2.view+                    (Data.ProtoLens.Field.field @"maybe'deprecated") _x+              of+                Prelude.Nothing -> Data.Monoid.mempty+                (Prelude.Just _v)+                  -> (Data.Monoid.<>)+                       (Data.ProtoLens.Encoding.Bytes.putVarInt 264)+                       ((Prelude..)+                          Data.ProtoLens.Encoding.Bytes.putVarInt+                          (\ b -> if b then 1 else 0)+                          _v))+             ((Data.Monoid.<>)+                (Data.ProtoLens.Encoding.Bytes.foldMapBuilder+                   (\ _v+                      -> (Data.Monoid.<>)+                           (Data.ProtoLens.Encoding.Bytes.putVarInt 7994)+                           ((Prelude..)+                              (\ bs+                                 -> (Data.Monoid.<>)+                                      (Data.ProtoLens.Encoding.Bytes.putVarInt+                                         (Prelude.fromIntegral (Data.ByteString.length bs)))+                                      (Data.ProtoLens.Encoding.Bytes.putBytes bs))+                              Data.ProtoLens.encodeMessage+                              _v))+                   (Lens.Family2.view+                      (Data.ProtoLens.Field.field @"vec'uninterpretedOption") _x))+                (Data.ProtoLens.Encoding.Wire.buildFieldSet+                   (Lens.Family2.view Data.ProtoLens.unknownFields _x)))+instance Control.DeepSeq.NFData ServiceOptions where+  rnf+    = \ x__+        -> Control.DeepSeq.deepseq+             (_ServiceOptions'_unknownFields x__)+             (Control.DeepSeq.deepseq+                (_ServiceOptions'deprecated x__)+                (Control.DeepSeq.deepseq+                   (_ServiceOptions'uninterpretedOption x__) ()))+{- | Fields :+     +         * 'Proto.Google.Protobuf.Descriptor_Fields.location' @:: Lens' SourceCodeInfo [SourceCodeInfo'Location]@+         * 'Proto.Google.Protobuf.Descriptor_Fields.vec'location' @:: Lens' SourceCodeInfo (Data.Vector.Vector SourceCodeInfo'Location)@ -}+data SourceCodeInfo+  = SourceCodeInfo'_constructor {_SourceCodeInfo'location :: !(Data.Vector.Vector SourceCodeInfo'Location),+                                 _SourceCodeInfo'_unknownFields :: !Data.ProtoLens.FieldSet}+  deriving (Prelude.Eq, Prelude.Ord)+instance Prelude.Show SourceCodeInfo where+  showsPrec _ __x __s+    = Prelude.showChar+        '{'+        (Prelude.showString+           (Data.ProtoLens.showMessageShort __x) (Prelude.showChar '}' __s))+instance Data.ProtoLens.Field.HasField SourceCodeInfo "location" [SourceCodeInfo'Location] where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _SourceCodeInfo'location+           (\ x__ y__ -> x__ {_SourceCodeInfo'location = y__}))+        (Lens.Family2.Unchecked.lens+           Data.Vector.Generic.toList+           (\ _ y__ -> Data.Vector.Generic.fromList y__))+instance Data.ProtoLens.Field.HasField SourceCodeInfo "vec'location" (Data.Vector.Vector SourceCodeInfo'Location) where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _SourceCodeInfo'location+           (\ x__ y__ -> x__ {_SourceCodeInfo'location = y__}))+        Prelude.id+instance Data.ProtoLens.Message SourceCodeInfo where+  messageName _ = Data.Text.pack "google.protobuf.SourceCodeInfo"+  fieldsByTag+    = let+        location__field_descriptor+          = Data.ProtoLens.FieldDescriptor+              "location"+              (Data.ProtoLens.MessageField Data.ProtoLens.MessageType ::+                 Data.ProtoLens.FieldTypeDescriptor SourceCodeInfo'Location)+              (Data.ProtoLens.RepeatedField+                 Data.ProtoLens.Unpacked+                 (Data.ProtoLens.Field.field @"location")) ::+              Data.ProtoLens.FieldDescriptor SourceCodeInfo+      in+        Data.Map.fromList+          [(Data.ProtoLens.Tag 1, location__field_descriptor)]+  unknownFields+    = Lens.Family2.Unchecked.lens+        _SourceCodeInfo'_unknownFields+        (\ x__ y__ -> x__ {_SourceCodeInfo'_unknownFields = y__})+  defMessage+    = SourceCodeInfo'_constructor+        {_SourceCodeInfo'location = Data.Vector.Generic.empty,+         _SourceCodeInfo'_unknownFields = []}+  parseMessage+    = let+        loop ::+          SourceCodeInfo+          -> Data.ProtoLens.Encoding.Growing.Growing Data.Vector.Vector Data.ProtoLens.Encoding.Growing.RealWorld SourceCodeInfo'Location+             -> Data.ProtoLens.Encoding.Bytes.Parser SourceCodeInfo+        loop x mutable'location+          = do end <- Data.ProtoLens.Encoding.Bytes.atEnd+               if end then+                   do frozen'location <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO+                                           (Data.ProtoLens.Encoding.Growing.unsafeFreeze+                                              mutable'location)+                      (let missing = []+                       in+                         if Prelude.null missing then+                             Prelude.return ()+                         else+                             Prelude.fail+                               ((Prelude.++)+                                  "Missing required fields: "+                                  (Prelude.show (missing :: [Prelude.String]))))+                      Prelude.return+                        (Lens.Family2.over+                           Data.ProtoLens.unknownFields+                           (\ !t -> Prelude.reverse t)+                           (Lens.Family2.set+                              (Data.ProtoLens.Field.field @"vec'location") frozen'location x))+               else+                   do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt+                      case tag of+                        10+                          -> do !y <- (Data.ProtoLens.Encoding.Bytes.<?>)+                                        (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt+                                            Data.ProtoLens.Encoding.Bytes.isolate+                                              (Prelude.fromIntegral len)+                                              Data.ProtoLens.parseMessage)+                                        "location"+                                v <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO+                                       (Data.ProtoLens.Encoding.Growing.append mutable'location y)+                                loop x v+                        wire+                          -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire+                                        wire+                                loop+                                  (Lens.Family2.over+                                     Data.ProtoLens.unknownFields (\ !t -> (:) y t) x)+                                  mutable'location+      in+        (Data.ProtoLens.Encoding.Bytes.<?>)+          (do mutable'location <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO+                                    Data.ProtoLens.Encoding.Growing.new+              loop Data.ProtoLens.defMessage mutable'location)+          "SourceCodeInfo"+  buildMessage+    = \ _x+        -> (Data.Monoid.<>)+             (Data.ProtoLens.Encoding.Bytes.foldMapBuilder+                (\ _v+                   -> (Data.Monoid.<>)+                        (Data.ProtoLens.Encoding.Bytes.putVarInt 10)+                        ((Prelude..)+                           (\ bs+                              -> (Data.Monoid.<>)+                                   (Data.ProtoLens.Encoding.Bytes.putVarInt+                                      (Prelude.fromIntegral (Data.ByteString.length bs)))+                                   (Data.ProtoLens.Encoding.Bytes.putBytes bs))+                           Data.ProtoLens.encodeMessage+                           _v))+                (Lens.Family2.view+                   (Data.ProtoLens.Field.field @"vec'location") _x))+             (Data.ProtoLens.Encoding.Wire.buildFieldSet+                (Lens.Family2.view Data.ProtoLens.unknownFields _x))+instance Control.DeepSeq.NFData SourceCodeInfo where+  rnf+    = \ x__+        -> Control.DeepSeq.deepseq+             (_SourceCodeInfo'_unknownFields x__)+             (Control.DeepSeq.deepseq (_SourceCodeInfo'location x__) ())+{- | Fields :+     +         * 'Proto.Google.Protobuf.Descriptor_Fields.path' @:: Lens' SourceCodeInfo'Location [Data.Int.Int32]@+         * 'Proto.Google.Protobuf.Descriptor_Fields.vec'path' @:: Lens' SourceCodeInfo'Location (Data.Vector.Unboxed.Vector Data.Int.Int32)@+         * 'Proto.Google.Protobuf.Descriptor_Fields.span' @:: Lens' SourceCodeInfo'Location [Data.Int.Int32]@+         * 'Proto.Google.Protobuf.Descriptor_Fields.vec'span' @:: Lens' SourceCodeInfo'Location (Data.Vector.Unboxed.Vector Data.Int.Int32)@+         * 'Proto.Google.Protobuf.Descriptor_Fields.leadingComments' @:: Lens' SourceCodeInfo'Location Data.Text.Text@+         * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'leadingComments' @:: Lens' SourceCodeInfo'Location (Prelude.Maybe Data.Text.Text)@+         * 'Proto.Google.Protobuf.Descriptor_Fields.trailingComments' @:: Lens' SourceCodeInfo'Location Data.Text.Text@+         * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'trailingComments' @:: Lens' SourceCodeInfo'Location (Prelude.Maybe Data.Text.Text)@+         * 'Proto.Google.Protobuf.Descriptor_Fields.leadingDetachedComments' @:: Lens' SourceCodeInfo'Location [Data.Text.Text]@+         * 'Proto.Google.Protobuf.Descriptor_Fields.vec'leadingDetachedComments' @:: Lens' SourceCodeInfo'Location (Data.Vector.Vector Data.Text.Text)@ -}+data SourceCodeInfo'Location+  = SourceCodeInfo'Location'_constructor {_SourceCodeInfo'Location'path :: !(Data.Vector.Unboxed.Vector Data.Int.Int32),+                                          _SourceCodeInfo'Location'span :: !(Data.Vector.Unboxed.Vector Data.Int.Int32),+                                          _SourceCodeInfo'Location'leadingComments :: !(Prelude.Maybe Data.Text.Text),+                                          _SourceCodeInfo'Location'trailingComments :: !(Prelude.Maybe Data.Text.Text),+                                          _SourceCodeInfo'Location'leadingDetachedComments :: !(Data.Vector.Vector Data.Text.Text),+                                          _SourceCodeInfo'Location'_unknownFields :: !Data.ProtoLens.FieldSet}+  deriving (Prelude.Eq, Prelude.Ord)+instance Prelude.Show SourceCodeInfo'Location where+  showsPrec _ __x __s+    = Prelude.showChar+        '{'+        (Prelude.showString+           (Data.ProtoLens.showMessageShort __x) (Prelude.showChar '}' __s))+instance Data.ProtoLens.Field.HasField SourceCodeInfo'Location "path" [Data.Int.Int32] where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _SourceCodeInfo'Location'path+           (\ x__ y__ -> x__ {_SourceCodeInfo'Location'path = y__}))+        (Lens.Family2.Unchecked.lens+           Data.Vector.Generic.toList+           (\ _ y__ -> Data.Vector.Generic.fromList y__))+instance Data.ProtoLens.Field.HasField SourceCodeInfo'Location "vec'path" (Data.Vector.Unboxed.Vector Data.Int.Int32) where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _SourceCodeInfo'Location'path+           (\ x__ y__ -> x__ {_SourceCodeInfo'Location'path = y__}))+        Prelude.id+instance Data.ProtoLens.Field.HasField SourceCodeInfo'Location "span" [Data.Int.Int32] where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _SourceCodeInfo'Location'span+           (\ x__ y__ -> x__ {_SourceCodeInfo'Location'span = y__}))+        (Lens.Family2.Unchecked.lens+           Data.Vector.Generic.toList+           (\ _ y__ -> Data.Vector.Generic.fromList y__))+instance Data.ProtoLens.Field.HasField SourceCodeInfo'Location "vec'span" (Data.Vector.Unboxed.Vector Data.Int.Int32) where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _SourceCodeInfo'Location'span+           (\ x__ y__ -> x__ {_SourceCodeInfo'Location'span = y__}))+        Prelude.id+instance Data.ProtoLens.Field.HasField SourceCodeInfo'Location "leadingComments" Data.Text.Text where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _SourceCodeInfo'Location'leadingComments+           (\ x__ y__+              -> x__ {_SourceCodeInfo'Location'leadingComments = y__}))+        (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault)+instance Data.ProtoLens.Field.HasField SourceCodeInfo'Location "maybe'leadingComments" (Prelude.Maybe Data.Text.Text) where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _SourceCodeInfo'Location'leadingComments+           (\ x__ y__+              -> x__ {_SourceCodeInfo'Location'leadingComments = y__}))+        Prelude.id+instance Data.ProtoLens.Field.HasField SourceCodeInfo'Location "trailingComments" Data.Text.Text where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _SourceCodeInfo'Location'trailingComments+           (\ x__ y__+              -> x__ {_SourceCodeInfo'Location'trailingComments = y__}))+        (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault)+instance Data.ProtoLens.Field.HasField SourceCodeInfo'Location "maybe'trailingComments" (Prelude.Maybe Data.Text.Text) where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _SourceCodeInfo'Location'trailingComments+           (\ x__ y__+              -> x__ {_SourceCodeInfo'Location'trailingComments = y__}))+        Prelude.id+instance Data.ProtoLens.Field.HasField SourceCodeInfo'Location "leadingDetachedComments" [Data.Text.Text] where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _SourceCodeInfo'Location'leadingDetachedComments+           (\ x__ y__+              -> x__ {_SourceCodeInfo'Location'leadingDetachedComments = y__}))+        (Lens.Family2.Unchecked.lens+           Data.Vector.Generic.toList+           (\ _ y__ -> Data.Vector.Generic.fromList y__))+instance Data.ProtoLens.Field.HasField SourceCodeInfo'Location "vec'leadingDetachedComments" (Data.Vector.Vector Data.Text.Text) where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _SourceCodeInfo'Location'leadingDetachedComments+           (\ x__ y__+              -> x__ {_SourceCodeInfo'Location'leadingDetachedComments = y__}))+        Prelude.id+instance Data.ProtoLens.Message SourceCodeInfo'Location where+  messageName _+    = Data.Text.pack "google.protobuf.SourceCodeInfo.Location"+  fieldsByTag+    = let+        path__field_descriptor+          = Data.ProtoLens.FieldDescriptor+              "path"+              (Data.ProtoLens.ScalarField Data.ProtoLens.Int32Field ::+                 Data.ProtoLens.FieldTypeDescriptor Data.Int.Int32)+              (Data.ProtoLens.RepeatedField+                 Data.ProtoLens.Packed (Data.ProtoLens.Field.field @"path")) ::+              Data.ProtoLens.FieldDescriptor SourceCodeInfo'Location+        span__field_descriptor+          = Data.ProtoLens.FieldDescriptor+              "span"+              (Data.ProtoLens.ScalarField Data.ProtoLens.Int32Field ::+                 Data.ProtoLens.FieldTypeDescriptor Data.Int.Int32)+              (Data.ProtoLens.RepeatedField+                 Data.ProtoLens.Packed (Data.ProtoLens.Field.field @"span")) ::+              Data.ProtoLens.FieldDescriptor SourceCodeInfo'Location+        leadingComments__field_descriptor+          = Data.ProtoLens.FieldDescriptor+              "leading_comments"+              (Data.ProtoLens.ScalarField Data.ProtoLens.StringField ::+                 Data.ProtoLens.FieldTypeDescriptor Data.Text.Text)+              (Data.ProtoLens.OptionalField+                 (Data.ProtoLens.Field.field @"maybe'leadingComments")) ::+              Data.ProtoLens.FieldDescriptor SourceCodeInfo'Location+        trailingComments__field_descriptor+          = Data.ProtoLens.FieldDescriptor+              "trailing_comments"+              (Data.ProtoLens.ScalarField Data.ProtoLens.StringField ::+                 Data.ProtoLens.FieldTypeDescriptor Data.Text.Text)+              (Data.ProtoLens.OptionalField+                 (Data.ProtoLens.Field.field @"maybe'trailingComments")) ::+              Data.ProtoLens.FieldDescriptor SourceCodeInfo'Location+        leadingDetachedComments__field_descriptor+          = Data.ProtoLens.FieldDescriptor+              "leading_detached_comments"+              (Data.ProtoLens.ScalarField Data.ProtoLens.StringField ::+                 Data.ProtoLens.FieldTypeDescriptor Data.Text.Text)+              (Data.ProtoLens.RepeatedField+                 Data.ProtoLens.Unpacked+                 (Data.ProtoLens.Field.field @"leadingDetachedComments")) ::+              Data.ProtoLens.FieldDescriptor SourceCodeInfo'Location+      in+        Data.Map.fromList+          [(Data.ProtoLens.Tag 1, path__field_descriptor),+           (Data.ProtoLens.Tag 2, span__field_descriptor),+           (Data.ProtoLens.Tag 3, leadingComments__field_descriptor),+           (Data.ProtoLens.Tag 4, trailingComments__field_descriptor),+           (Data.ProtoLens.Tag 6, leadingDetachedComments__field_descriptor)]+  unknownFields+    = Lens.Family2.Unchecked.lens+        _SourceCodeInfo'Location'_unknownFields+        (\ x__ y__ -> x__ {_SourceCodeInfo'Location'_unknownFields = y__})+  defMessage+    = SourceCodeInfo'Location'_constructor+        {_SourceCodeInfo'Location'path = Data.Vector.Generic.empty,+         _SourceCodeInfo'Location'span = Data.Vector.Generic.empty,+         _SourceCodeInfo'Location'leadingComments = Prelude.Nothing,+         _SourceCodeInfo'Location'trailingComments = Prelude.Nothing,+         _SourceCodeInfo'Location'leadingDetachedComments = Data.Vector.Generic.empty,+         _SourceCodeInfo'Location'_unknownFields = []}+  parseMessage+    = let+        loop ::+          SourceCodeInfo'Location+          -> Data.ProtoLens.Encoding.Growing.Growing Data.Vector.Vector Data.ProtoLens.Encoding.Growing.RealWorld Data.Text.Text+             -> Data.ProtoLens.Encoding.Growing.Growing Data.Vector.Unboxed.Vector Data.ProtoLens.Encoding.Growing.RealWorld Data.Int.Int32+                -> Data.ProtoLens.Encoding.Growing.Growing Data.Vector.Unboxed.Vector Data.ProtoLens.Encoding.Growing.RealWorld Data.Int.Int32+                   -> Data.ProtoLens.Encoding.Bytes.Parser SourceCodeInfo'Location+        loop x mutable'leadingDetachedComments mutable'path mutable'span+          = do end <- Data.ProtoLens.Encoding.Bytes.atEnd+               if end then+                   do frozen'leadingDetachedComments <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO+                                                          (Data.ProtoLens.Encoding.Growing.unsafeFreeze+                                                             mutable'leadingDetachedComments)+                      frozen'path <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO+                                       (Data.ProtoLens.Encoding.Growing.unsafeFreeze mutable'path)+                      frozen'span <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO+                                       (Data.ProtoLens.Encoding.Growing.unsafeFreeze mutable'span)+                      (let missing = []+                       in+                         if Prelude.null missing then+                             Prelude.return ()+                         else+                             Prelude.fail+                               ((Prelude.++)+                                  "Missing required fields: "+                                  (Prelude.show (missing :: [Prelude.String]))))+                      Prelude.return+                        (Lens.Family2.over+                           Data.ProtoLens.unknownFields+                           (\ !t -> Prelude.reverse t)+                           (Lens.Family2.set+                              (Data.ProtoLens.Field.field @"vec'leadingDetachedComments")+                              frozen'leadingDetachedComments+                              (Lens.Family2.set+                                 (Data.ProtoLens.Field.field @"vec'path")+                                 frozen'path+                                 (Lens.Family2.set+                                    (Data.ProtoLens.Field.field @"vec'span") frozen'span x))))+               else+                   do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt+                      case tag of+                        8 -> do !y <- (Data.ProtoLens.Encoding.Bytes.<?>)+                                        (Prelude.fmap+                                           Prelude.fromIntegral+                                           Data.ProtoLens.Encoding.Bytes.getVarInt)+                                        "path"+                                v <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO+                                       (Data.ProtoLens.Encoding.Growing.append mutable'path y)+                                loop x mutable'leadingDetachedComments v mutable'span+                        10+                          -> do y <- do len <- Data.ProtoLens.Encoding.Bytes.getVarInt+                                        Data.ProtoLens.Encoding.Bytes.isolate+                                          (Prelude.fromIntegral len)+                                          ((let+                                              ploop qs+                                                = do packedEnd <- Data.ProtoLens.Encoding.Bytes.atEnd+                                                     if packedEnd then+                                                         Prelude.return qs+                                                     else+                                                         do !q <- (Data.ProtoLens.Encoding.Bytes.<?>)+                                                                    (Prelude.fmap+                                                                       Prelude.fromIntegral+                                                                       Data.ProtoLens.Encoding.Bytes.getVarInt)+                                                                    "path"+                                                            qs' <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO+                                                                     (Data.ProtoLens.Encoding.Growing.append+                                                                        qs q)+                                                            ploop qs'+                                            in ploop)+                                             mutable'path)+                                loop x mutable'leadingDetachedComments y mutable'span+                        16+                          -> do !y <- (Data.ProtoLens.Encoding.Bytes.<?>)+                                        (Prelude.fmap+                                           Prelude.fromIntegral+                                           Data.ProtoLens.Encoding.Bytes.getVarInt)+                                        "span"+                                v <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO+                                       (Data.ProtoLens.Encoding.Growing.append mutable'span y)+                                loop x mutable'leadingDetachedComments mutable'path v+                        18+                          -> do y <- do len <- Data.ProtoLens.Encoding.Bytes.getVarInt+                                        Data.ProtoLens.Encoding.Bytes.isolate+                                          (Prelude.fromIntegral len)+                                          ((let+                                              ploop qs+                                                = do packedEnd <- Data.ProtoLens.Encoding.Bytes.atEnd+                                                     if packedEnd then+                                                         Prelude.return qs+                                                     else+                                                         do !q <- (Data.ProtoLens.Encoding.Bytes.<?>)+                                                                    (Prelude.fmap+                                                                       Prelude.fromIntegral+                                                                       Data.ProtoLens.Encoding.Bytes.getVarInt)+                                                                    "span"+                                                            qs' <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO+                                                                     (Data.ProtoLens.Encoding.Growing.append+                                                                        qs q)+                                                            ploop qs'+                                            in ploop)+                                             mutable'span)+                                loop x mutable'leadingDetachedComments mutable'path y+                        26+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)+                                       (do value <- do len <- Data.ProtoLens.Encoding.Bytes.getVarInt+                                                       Data.ProtoLens.Encoding.Bytes.getBytes+                                                         (Prelude.fromIntegral len)+                                           Data.ProtoLens.Encoding.Bytes.runEither+                                             (case Data.Text.Encoding.decodeUtf8' value of+                                                (Prelude.Left err)+                                                  -> Prelude.Left (Prelude.show err)+                                                (Prelude.Right r) -> Prelude.Right r))+                                       "leading_comments"+                                loop+                                  (Lens.Family2.set+                                     (Data.ProtoLens.Field.field @"leadingComments") y x)+                                  mutable'leadingDetachedComments+                                  mutable'path+                                  mutable'span+                        34+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)+                                       (do value <- do len <- Data.ProtoLens.Encoding.Bytes.getVarInt+                                                       Data.ProtoLens.Encoding.Bytes.getBytes+                                                         (Prelude.fromIntegral len)+                                           Data.ProtoLens.Encoding.Bytes.runEither+                                             (case Data.Text.Encoding.decodeUtf8' value of+                                                (Prelude.Left err)+                                                  -> Prelude.Left (Prelude.show err)+                                                (Prelude.Right r) -> Prelude.Right r))+                                       "trailing_comments"+                                loop+                                  (Lens.Family2.set+                                     (Data.ProtoLens.Field.field @"trailingComments") y x)+                                  mutable'leadingDetachedComments+                                  mutable'path+                                  mutable'span+                        50+                          -> do !y <- (Data.ProtoLens.Encoding.Bytes.<?>)+                                        (do value <- do len <- Data.ProtoLens.Encoding.Bytes.getVarInt+                                                        Data.ProtoLens.Encoding.Bytes.getBytes+                                                          (Prelude.fromIntegral len)+                                            Data.ProtoLens.Encoding.Bytes.runEither+                                              (case Data.Text.Encoding.decodeUtf8' value of+                                                 (Prelude.Left err)+                                                   -> Prelude.Left (Prelude.show err)+                                                 (Prelude.Right r) -> Prelude.Right r))+                                        "leading_detached_comments"+                                v <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO+                                       (Data.ProtoLens.Encoding.Growing.append+                                          mutable'leadingDetachedComments y)+                                loop x v mutable'path mutable'span+                        wire+                          -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire+                                        wire+                                loop+                                  (Lens.Family2.over+                                     Data.ProtoLens.unknownFields (\ !t -> (:) y t) x)+                                  mutable'leadingDetachedComments+                                  mutable'path+                                  mutable'span+      in+        (Data.ProtoLens.Encoding.Bytes.<?>)+          (do mutable'leadingDetachedComments <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO+                                                   Data.ProtoLens.Encoding.Growing.new+              mutable'path <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO+                                Data.ProtoLens.Encoding.Growing.new+              mutable'span <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO+                                Data.ProtoLens.Encoding.Growing.new+              loop+                Data.ProtoLens.defMessage+                mutable'leadingDetachedComments+                mutable'path+                mutable'span)+          "Location"+  buildMessage+    = \ _x+        -> (Data.Monoid.<>)+             (let+                p = Lens.Family2.view (Data.ProtoLens.Field.field @"vec'path") _x+              in+                if Data.Vector.Generic.null p then+                    Data.Monoid.mempty+                else+                    (Data.Monoid.<>)+                      (Data.ProtoLens.Encoding.Bytes.putVarInt 10)+                      ((\ bs+                          -> (Data.Monoid.<>)+                               (Data.ProtoLens.Encoding.Bytes.putVarInt+                                  (Prelude.fromIntegral (Data.ByteString.length bs)))+                               (Data.ProtoLens.Encoding.Bytes.putBytes bs))+                         (Data.ProtoLens.Encoding.Bytes.runBuilder+                            (Data.ProtoLens.Encoding.Bytes.foldMapBuilder+                               ((Prelude..)+                                  Data.ProtoLens.Encoding.Bytes.putVarInt Prelude.fromIntegral)+                               p))))+             ((Data.Monoid.<>)+                (let+                   p = Lens.Family2.view (Data.ProtoLens.Field.field @"vec'span") _x+                 in+                   if Data.Vector.Generic.null p then+                       Data.Monoid.mempty+                   else+                       (Data.Monoid.<>)+                         (Data.ProtoLens.Encoding.Bytes.putVarInt 18)+                         ((\ bs+                             -> (Data.Monoid.<>)+                                  (Data.ProtoLens.Encoding.Bytes.putVarInt+                                     (Prelude.fromIntegral (Data.ByteString.length bs)))+                                  (Data.ProtoLens.Encoding.Bytes.putBytes bs))+                            (Data.ProtoLens.Encoding.Bytes.runBuilder+                               (Data.ProtoLens.Encoding.Bytes.foldMapBuilder+                                  ((Prelude..)+                                     Data.ProtoLens.Encoding.Bytes.putVarInt Prelude.fromIntegral)+                                  p))))+                ((Data.Monoid.<>)+                   (case+                        Lens.Family2.view+                          (Data.ProtoLens.Field.field @"maybe'leadingComments") _x+                    of+                      Prelude.Nothing -> Data.Monoid.mempty+                      (Prelude.Just _v)+                        -> (Data.Monoid.<>)+                             (Data.ProtoLens.Encoding.Bytes.putVarInt 26)+                             ((Prelude..)+                                (\ bs+                                   -> (Data.Monoid.<>)+                                        (Data.ProtoLens.Encoding.Bytes.putVarInt+                                           (Prelude.fromIntegral (Data.ByteString.length bs)))+                                        (Data.ProtoLens.Encoding.Bytes.putBytes bs))+                                Data.Text.Encoding.encodeUtf8+                                _v))+                   ((Data.Monoid.<>)+                      (case+                           Lens.Family2.view+                             (Data.ProtoLens.Field.field @"maybe'trailingComments") _x+                       of+                         Prelude.Nothing -> Data.Monoid.mempty+                         (Prelude.Just _v)+                           -> (Data.Monoid.<>)+                                (Data.ProtoLens.Encoding.Bytes.putVarInt 34)+                                ((Prelude..)+                                   (\ bs+                                      -> (Data.Monoid.<>)+                                           (Data.ProtoLens.Encoding.Bytes.putVarInt+                                              (Prelude.fromIntegral (Data.ByteString.length bs)))+                                           (Data.ProtoLens.Encoding.Bytes.putBytes bs))+                                   Data.Text.Encoding.encodeUtf8+                                   _v))+                      ((Data.Monoid.<>)+                         (Data.ProtoLens.Encoding.Bytes.foldMapBuilder+                            (\ _v+                               -> (Data.Monoid.<>)+                                    (Data.ProtoLens.Encoding.Bytes.putVarInt 50)+                                    ((Prelude..)+                                       (\ bs+                                          -> (Data.Monoid.<>)+                                               (Data.ProtoLens.Encoding.Bytes.putVarInt+                                                  (Prelude.fromIntegral+                                                     (Data.ByteString.length bs)))+                                               (Data.ProtoLens.Encoding.Bytes.putBytes bs))+                                       Data.Text.Encoding.encodeUtf8+                                       _v))+                            (Lens.Family2.view+                               (Data.ProtoLens.Field.field @"vec'leadingDetachedComments") _x))+                         (Data.ProtoLens.Encoding.Wire.buildFieldSet+                            (Lens.Family2.view Data.ProtoLens.unknownFields _x))))))+instance Control.DeepSeq.NFData SourceCodeInfo'Location where+  rnf+    = \ x__+        -> Control.DeepSeq.deepseq+             (_SourceCodeInfo'Location'_unknownFields x__)+             (Control.DeepSeq.deepseq+                (_SourceCodeInfo'Location'path x__)+                (Control.DeepSeq.deepseq+                   (_SourceCodeInfo'Location'span x__)+                   (Control.DeepSeq.deepseq+                      (_SourceCodeInfo'Location'leadingComments x__)+                      (Control.DeepSeq.deepseq+                         (_SourceCodeInfo'Location'trailingComments x__)+                         (Control.DeepSeq.deepseq+                            (_SourceCodeInfo'Location'leadingDetachedComments x__) ())))))+{- | Fields :+     +         * 'Proto.Google.Protobuf.Descriptor_Fields.name' @:: Lens' UninterpretedOption [UninterpretedOption'NamePart]@+         * 'Proto.Google.Protobuf.Descriptor_Fields.vec'name' @:: Lens' UninterpretedOption (Data.Vector.Vector UninterpretedOption'NamePart)@+         * 'Proto.Google.Protobuf.Descriptor_Fields.identifierValue' @:: Lens' UninterpretedOption Data.Text.Text@+         * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'identifierValue' @:: Lens' UninterpretedOption (Prelude.Maybe Data.Text.Text)@+         * 'Proto.Google.Protobuf.Descriptor_Fields.positiveIntValue' @:: Lens' UninterpretedOption Data.Word.Word64@+         * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'positiveIntValue' @:: Lens' UninterpretedOption (Prelude.Maybe Data.Word.Word64)@+         * 'Proto.Google.Protobuf.Descriptor_Fields.negativeIntValue' @:: Lens' UninterpretedOption Data.Int.Int64@+         * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'negativeIntValue' @:: Lens' UninterpretedOption (Prelude.Maybe Data.Int.Int64)@+         * 'Proto.Google.Protobuf.Descriptor_Fields.doubleValue' @:: Lens' UninterpretedOption Prelude.Double@+         * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'doubleValue' @:: Lens' UninterpretedOption (Prelude.Maybe Prelude.Double)@+         * 'Proto.Google.Protobuf.Descriptor_Fields.stringValue' @:: Lens' UninterpretedOption Data.ByteString.ByteString@+         * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'stringValue' @:: Lens' UninterpretedOption (Prelude.Maybe Data.ByteString.ByteString)@+         * 'Proto.Google.Protobuf.Descriptor_Fields.aggregateValue' @:: Lens' UninterpretedOption Data.Text.Text@+         * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'aggregateValue' @:: Lens' UninterpretedOption (Prelude.Maybe Data.Text.Text)@ -}+data UninterpretedOption+  = UninterpretedOption'_constructor {_UninterpretedOption'name :: !(Data.Vector.Vector UninterpretedOption'NamePart),+                                      _UninterpretedOption'identifierValue :: !(Prelude.Maybe Data.Text.Text),+                                      _UninterpretedOption'positiveIntValue :: !(Prelude.Maybe Data.Word.Word64),+                                      _UninterpretedOption'negativeIntValue :: !(Prelude.Maybe Data.Int.Int64),+                                      _UninterpretedOption'doubleValue :: !(Prelude.Maybe Prelude.Double),+                                      _UninterpretedOption'stringValue :: !(Prelude.Maybe Data.ByteString.ByteString),+                                      _UninterpretedOption'aggregateValue :: !(Prelude.Maybe Data.Text.Text),+                                      _UninterpretedOption'_unknownFields :: !Data.ProtoLens.FieldSet}+  deriving (Prelude.Eq, Prelude.Ord)+instance Prelude.Show UninterpretedOption where+  showsPrec _ __x __s+    = Prelude.showChar+        '{'+        (Prelude.showString+           (Data.ProtoLens.showMessageShort __x) (Prelude.showChar '}' __s))+instance Data.ProtoLens.Field.HasField UninterpretedOption "name" [UninterpretedOption'NamePart] where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _UninterpretedOption'name+           (\ x__ y__ -> x__ {_UninterpretedOption'name = y__}))+        (Lens.Family2.Unchecked.lens+           Data.Vector.Generic.toList+           (\ _ y__ -> Data.Vector.Generic.fromList y__))+instance Data.ProtoLens.Field.HasField UninterpretedOption "vec'name" (Data.Vector.Vector UninterpretedOption'NamePart) where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _UninterpretedOption'name+           (\ x__ y__ -> x__ {_UninterpretedOption'name = y__}))+        Prelude.id+instance Data.ProtoLens.Field.HasField UninterpretedOption "identifierValue" Data.Text.Text where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _UninterpretedOption'identifierValue+           (\ x__ y__ -> x__ {_UninterpretedOption'identifierValue = y__}))+        (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault)+instance Data.ProtoLens.Field.HasField UninterpretedOption "maybe'identifierValue" (Prelude.Maybe Data.Text.Text) where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _UninterpretedOption'identifierValue+           (\ x__ y__ -> x__ {_UninterpretedOption'identifierValue = y__}))+        Prelude.id+instance Data.ProtoLens.Field.HasField UninterpretedOption "positiveIntValue" Data.Word.Word64 where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _UninterpretedOption'positiveIntValue+           (\ x__ y__ -> x__ {_UninterpretedOption'positiveIntValue = y__}))+        (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault)+instance Data.ProtoLens.Field.HasField UninterpretedOption "maybe'positiveIntValue" (Prelude.Maybe Data.Word.Word64) where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _UninterpretedOption'positiveIntValue+           (\ x__ y__ -> x__ {_UninterpretedOption'positiveIntValue = y__}))+        Prelude.id+instance Data.ProtoLens.Field.HasField UninterpretedOption "negativeIntValue" Data.Int.Int64 where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _UninterpretedOption'negativeIntValue+           (\ x__ y__ -> x__ {_UninterpretedOption'negativeIntValue = y__}))+        (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault)+instance Data.ProtoLens.Field.HasField UninterpretedOption "maybe'negativeIntValue" (Prelude.Maybe Data.Int.Int64) where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _UninterpretedOption'negativeIntValue+           (\ x__ y__ -> x__ {_UninterpretedOption'negativeIntValue = y__}))+        Prelude.id+instance Data.ProtoLens.Field.HasField UninterpretedOption "doubleValue" Prelude.Double where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _UninterpretedOption'doubleValue+           (\ x__ y__ -> x__ {_UninterpretedOption'doubleValue = y__}))+        (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault)+instance Data.ProtoLens.Field.HasField UninterpretedOption "maybe'doubleValue" (Prelude.Maybe Prelude.Double) where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _UninterpretedOption'doubleValue+           (\ x__ y__ -> x__ {_UninterpretedOption'doubleValue = y__}))+        Prelude.id+instance Data.ProtoLens.Field.HasField UninterpretedOption "stringValue" Data.ByteString.ByteString where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _UninterpretedOption'stringValue+           (\ x__ y__ -> x__ {_UninterpretedOption'stringValue = y__}))+        (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault)+instance Data.ProtoLens.Field.HasField UninterpretedOption "maybe'stringValue" (Prelude.Maybe Data.ByteString.ByteString) where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _UninterpretedOption'stringValue+           (\ x__ y__ -> x__ {_UninterpretedOption'stringValue = y__}))+        Prelude.id+instance Data.ProtoLens.Field.HasField UninterpretedOption "aggregateValue" Data.Text.Text where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _UninterpretedOption'aggregateValue+           (\ x__ y__ -> x__ {_UninterpretedOption'aggregateValue = y__}))+        (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault)+instance Data.ProtoLens.Field.HasField UninterpretedOption "maybe'aggregateValue" (Prelude.Maybe Data.Text.Text) where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _UninterpretedOption'aggregateValue+           (\ x__ y__ -> x__ {_UninterpretedOption'aggregateValue = y__}))+        Prelude.id+instance Data.ProtoLens.Message UninterpretedOption where+  messageName _+    = Data.Text.pack "google.protobuf.UninterpretedOption"+  fieldsByTag+    = let+        name__field_descriptor+          = Data.ProtoLens.FieldDescriptor+              "name"+              (Data.ProtoLens.MessageField Data.ProtoLens.MessageType ::+                 Data.ProtoLens.FieldTypeDescriptor UninterpretedOption'NamePart)+              (Data.ProtoLens.RepeatedField+                 Data.ProtoLens.Unpacked (Data.ProtoLens.Field.field @"name")) ::+              Data.ProtoLens.FieldDescriptor UninterpretedOption+        identifierValue__field_descriptor+          = Data.ProtoLens.FieldDescriptor+              "identifier_value"+              (Data.ProtoLens.ScalarField Data.ProtoLens.StringField ::+                 Data.ProtoLens.FieldTypeDescriptor Data.Text.Text)+              (Data.ProtoLens.OptionalField+                 (Data.ProtoLens.Field.field @"maybe'identifierValue")) ::+              Data.ProtoLens.FieldDescriptor UninterpretedOption+        positiveIntValue__field_descriptor+          = Data.ProtoLens.FieldDescriptor+              "positive_int_value"+              (Data.ProtoLens.ScalarField Data.ProtoLens.UInt64Field ::+                 Data.ProtoLens.FieldTypeDescriptor Data.Word.Word64)+              (Data.ProtoLens.OptionalField+                 (Data.ProtoLens.Field.field @"maybe'positiveIntValue")) ::+              Data.ProtoLens.FieldDescriptor UninterpretedOption+        negativeIntValue__field_descriptor+          = Data.ProtoLens.FieldDescriptor+              "negative_int_value"+              (Data.ProtoLens.ScalarField Data.ProtoLens.Int64Field ::+                 Data.ProtoLens.FieldTypeDescriptor Data.Int.Int64)+              (Data.ProtoLens.OptionalField+                 (Data.ProtoLens.Field.field @"maybe'negativeIntValue")) ::+              Data.ProtoLens.FieldDescriptor UninterpretedOption+        doubleValue__field_descriptor+          = Data.ProtoLens.FieldDescriptor+              "double_value"+              (Data.ProtoLens.ScalarField Data.ProtoLens.DoubleField ::+                 Data.ProtoLens.FieldTypeDescriptor Prelude.Double)+              (Data.ProtoLens.OptionalField+                 (Data.ProtoLens.Field.field @"maybe'doubleValue")) ::+              Data.ProtoLens.FieldDescriptor UninterpretedOption+        stringValue__field_descriptor+          = Data.ProtoLens.FieldDescriptor+              "string_value"+              (Data.ProtoLens.ScalarField Data.ProtoLens.BytesField ::+                 Data.ProtoLens.FieldTypeDescriptor Data.ByteString.ByteString)+              (Data.ProtoLens.OptionalField+                 (Data.ProtoLens.Field.field @"maybe'stringValue")) ::+              Data.ProtoLens.FieldDescriptor UninterpretedOption+        aggregateValue__field_descriptor+          = Data.ProtoLens.FieldDescriptor+              "aggregate_value"+              (Data.ProtoLens.ScalarField Data.ProtoLens.StringField ::+                 Data.ProtoLens.FieldTypeDescriptor Data.Text.Text)+              (Data.ProtoLens.OptionalField+                 (Data.ProtoLens.Field.field @"maybe'aggregateValue")) ::+              Data.ProtoLens.FieldDescriptor UninterpretedOption+      in+        Data.Map.fromList+          [(Data.ProtoLens.Tag 2, name__field_descriptor),+           (Data.ProtoLens.Tag 3, identifierValue__field_descriptor),+           (Data.ProtoLens.Tag 4, positiveIntValue__field_descriptor),+           (Data.ProtoLens.Tag 5, negativeIntValue__field_descriptor),+           (Data.ProtoLens.Tag 6, doubleValue__field_descriptor),+           (Data.ProtoLens.Tag 7, stringValue__field_descriptor),+           (Data.ProtoLens.Tag 8, aggregateValue__field_descriptor)]+  unknownFields+    = Lens.Family2.Unchecked.lens+        _UninterpretedOption'_unknownFields+        (\ x__ y__ -> x__ {_UninterpretedOption'_unknownFields = y__})+  defMessage+    = UninterpretedOption'_constructor+        {_UninterpretedOption'name = Data.Vector.Generic.empty,+         _UninterpretedOption'identifierValue = Prelude.Nothing,+         _UninterpretedOption'positiveIntValue = Prelude.Nothing,+         _UninterpretedOption'negativeIntValue = Prelude.Nothing,+         _UninterpretedOption'doubleValue = Prelude.Nothing,+         _UninterpretedOption'stringValue = Prelude.Nothing,+         _UninterpretedOption'aggregateValue = Prelude.Nothing,+         _UninterpretedOption'_unknownFields = []}+  parseMessage+    = let+        loop ::+          UninterpretedOption+          -> Data.ProtoLens.Encoding.Growing.Growing Data.Vector.Vector Data.ProtoLens.Encoding.Growing.RealWorld UninterpretedOption'NamePart+             -> Data.ProtoLens.Encoding.Bytes.Parser UninterpretedOption+        loop x mutable'name+          = do end <- Data.ProtoLens.Encoding.Bytes.atEnd+               if end then+                   do frozen'name <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO+                                       (Data.ProtoLens.Encoding.Growing.unsafeFreeze mutable'name)+                      (let missing = []+                       in+                         if Prelude.null missing then+                             Prelude.return ()+                         else+                             Prelude.fail+                               ((Prelude.++)+                                  "Missing required fields: "+                                  (Prelude.show (missing :: [Prelude.String]))))+                      Prelude.return+                        (Lens.Family2.over+                           Data.ProtoLens.unknownFields+                           (\ !t -> Prelude.reverse t)+                           (Lens.Family2.set+                              (Data.ProtoLens.Field.field @"vec'name") frozen'name x))+               else+                   do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt+                      case tag of+                        18+                          -> do !y <- (Data.ProtoLens.Encoding.Bytes.<?>)+                                        (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt+                                            Data.ProtoLens.Encoding.Bytes.isolate+                                              (Prelude.fromIntegral len)+                                              Data.ProtoLens.parseMessage)+                                        "name"+                                v <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO+                                       (Data.ProtoLens.Encoding.Growing.append mutable'name y)+                                loop x v+                        26+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)+                                       (do value <- do len <- Data.ProtoLens.Encoding.Bytes.getVarInt+                                                       Data.ProtoLens.Encoding.Bytes.getBytes+                                                         (Prelude.fromIntegral len)+                                           Data.ProtoLens.Encoding.Bytes.runEither+                                             (case Data.Text.Encoding.decodeUtf8' value of+                                                (Prelude.Left err)+                                                  -> Prelude.Left (Prelude.show err)+                                                (Prelude.Right r) -> Prelude.Right r))+                                       "identifier_value"+                                loop+                                  (Lens.Family2.set+                                     (Data.ProtoLens.Field.field @"identifierValue") y x)+                                  mutable'name+                        32+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)+                                       Data.ProtoLens.Encoding.Bytes.getVarInt "positive_int_value"+                                loop+                                  (Lens.Family2.set+                                     (Data.ProtoLens.Field.field @"positiveIntValue") y x)+                                  mutable'name+                        40+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)+                                       (Prelude.fmap+                                          Prelude.fromIntegral+                                          Data.ProtoLens.Encoding.Bytes.getVarInt)+                                       "negative_int_value"+                                loop+                                  (Lens.Family2.set+                                     (Data.ProtoLens.Field.field @"negativeIntValue") y x)+                                  mutable'name+                        49+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)+                                       (Prelude.fmap+                                          Data.ProtoLens.Encoding.Bytes.wordToDouble+                                          Data.ProtoLens.Encoding.Bytes.getFixed64)+                                       "double_value"+                                loop+                                  (Lens.Family2.set (Data.ProtoLens.Field.field @"doubleValue") y x)+                                  mutable'name+                        58+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)+                                       (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt+                                           Data.ProtoLens.Encoding.Bytes.getBytes+                                             (Prelude.fromIntegral len))+                                       "string_value"+                                loop+                                  (Lens.Family2.set (Data.ProtoLens.Field.field @"stringValue") y x)+                                  mutable'name+                        66+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)+                                       (do value <- do len <- Data.ProtoLens.Encoding.Bytes.getVarInt+                                                       Data.ProtoLens.Encoding.Bytes.getBytes+                                                         (Prelude.fromIntegral len)+                                           Data.ProtoLens.Encoding.Bytes.runEither+                                             (case Data.Text.Encoding.decodeUtf8' value of+                                                (Prelude.Left err)+                                                  -> Prelude.Left (Prelude.show err)+                                                (Prelude.Right r) -> Prelude.Right r))+                                       "aggregate_value"+                                loop+                                  (Lens.Family2.set+                                     (Data.ProtoLens.Field.field @"aggregateValue") y x)+                                  mutable'name+                        wire+                          -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire+                                        wire+                                loop+                                  (Lens.Family2.over+                                     Data.ProtoLens.unknownFields (\ !t -> (:) y t) x)+                                  mutable'name+      in+        (Data.ProtoLens.Encoding.Bytes.<?>)+          (do mutable'name <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO+                                Data.ProtoLens.Encoding.Growing.new+              loop Data.ProtoLens.defMessage mutable'name)+          "UninterpretedOption"+  buildMessage+    = \ _x+        -> (Data.Monoid.<>)+             (Data.ProtoLens.Encoding.Bytes.foldMapBuilder+                (\ _v+                   -> (Data.Monoid.<>)+                        (Data.ProtoLens.Encoding.Bytes.putVarInt 18)+                        ((Prelude..)+                           (\ bs+                              -> (Data.Monoid.<>)+                                   (Data.ProtoLens.Encoding.Bytes.putVarInt+                                      (Prelude.fromIntegral (Data.ByteString.length bs)))+                                   (Data.ProtoLens.Encoding.Bytes.putBytes bs))+                           Data.ProtoLens.encodeMessage+                           _v))+                (Lens.Family2.view (Data.ProtoLens.Field.field @"vec'name") _x))+             ((Data.Monoid.<>)+                (case+                     Lens.Family2.view+                       (Data.ProtoLens.Field.field @"maybe'identifierValue") _x+                 of+                   Prelude.Nothing -> Data.Monoid.mempty+                   (Prelude.Just _v)+                     -> (Data.Monoid.<>)+                          (Data.ProtoLens.Encoding.Bytes.putVarInt 26)+                          ((Prelude..)+                             (\ bs+                                -> (Data.Monoid.<>)+                                     (Data.ProtoLens.Encoding.Bytes.putVarInt+                                        (Prelude.fromIntegral (Data.ByteString.length bs)))+                                     (Data.ProtoLens.Encoding.Bytes.putBytes bs))+                             Data.Text.Encoding.encodeUtf8+                             _v))+                ((Data.Monoid.<>)+                   (case+                        Lens.Family2.view+                          (Data.ProtoLens.Field.field @"maybe'positiveIntValue") _x+                    of+                      Prelude.Nothing -> Data.Monoid.mempty+                      (Prelude.Just _v)+                        -> (Data.Monoid.<>)+                             (Data.ProtoLens.Encoding.Bytes.putVarInt 32)+                             (Data.ProtoLens.Encoding.Bytes.putVarInt _v))+                   ((Data.Monoid.<>)+                      (case+                           Lens.Family2.view+                             (Data.ProtoLens.Field.field @"maybe'negativeIntValue") _x+                       of+                         Prelude.Nothing -> Data.Monoid.mempty+                         (Prelude.Just _v)+                           -> (Data.Monoid.<>)+                                (Data.ProtoLens.Encoding.Bytes.putVarInt 40)+                                ((Prelude..)+                                   Data.ProtoLens.Encoding.Bytes.putVarInt Prelude.fromIntegral _v))+                      ((Data.Monoid.<>)+                         (case+                              Lens.Family2.view+                                (Data.ProtoLens.Field.field @"maybe'doubleValue") _x+                          of+                            Prelude.Nothing -> Data.Monoid.mempty+                            (Prelude.Just _v)+                              -> (Data.Monoid.<>)+                                   (Data.ProtoLens.Encoding.Bytes.putVarInt 49)+                                   ((Prelude..)+                                      Data.ProtoLens.Encoding.Bytes.putFixed64+                                      Data.ProtoLens.Encoding.Bytes.doubleToWord+                                      _v))+                         ((Data.Monoid.<>)+                            (case+                                 Lens.Family2.view+                                   (Data.ProtoLens.Field.field @"maybe'stringValue") _x+                             of+                               Prelude.Nothing -> Data.Monoid.mempty+                               (Prelude.Just _v)+                                 -> (Data.Monoid.<>)+                                      (Data.ProtoLens.Encoding.Bytes.putVarInt 58)+                                      ((\ bs+                                          -> (Data.Monoid.<>)+                                               (Data.ProtoLens.Encoding.Bytes.putVarInt+                                                  (Prelude.fromIntegral+                                                     (Data.ByteString.length bs)))+                                               (Data.ProtoLens.Encoding.Bytes.putBytes bs))+                                         _v))+                            ((Data.Monoid.<>)+                               (case+                                    Lens.Family2.view+                                      (Data.ProtoLens.Field.field @"maybe'aggregateValue") _x+                                of+                                  Prelude.Nothing -> Data.Monoid.mempty+                                  (Prelude.Just _v)+                                    -> (Data.Monoid.<>)+                                         (Data.ProtoLens.Encoding.Bytes.putVarInt 66)+                                         ((Prelude..)+                                            (\ bs+                                               -> (Data.Monoid.<>)+                                                    (Data.ProtoLens.Encoding.Bytes.putVarInt+                                                       (Prelude.fromIntegral+                                                          (Data.ByteString.length bs)))+                                                    (Data.ProtoLens.Encoding.Bytes.putBytes bs))+                                            Data.Text.Encoding.encodeUtf8+                                            _v))+                               (Data.ProtoLens.Encoding.Wire.buildFieldSet+                                  (Lens.Family2.view Data.ProtoLens.unknownFields _x))))))))+instance Control.DeepSeq.NFData UninterpretedOption where+  rnf+    = \ x__+        -> Control.DeepSeq.deepseq+             (_UninterpretedOption'_unknownFields x__)+             (Control.DeepSeq.deepseq+                (_UninterpretedOption'name x__)+                (Control.DeepSeq.deepseq+                   (_UninterpretedOption'identifierValue x__)+                   (Control.DeepSeq.deepseq+                      (_UninterpretedOption'positiveIntValue x__)+                      (Control.DeepSeq.deepseq+                         (_UninterpretedOption'negativeIntValue x__)+                         (Control.DeepSeq.deepseq+                            (_UninterpretedOption'doubleValue x__)+                            (Control.DeepSeq.deepseq+                               (_UninterpretedOption'stringValue x__)+                               (Control.DeepSeq.deepseq+                                  (_UninterpretedOption'aggregateValue x__) ())))))))+{- | Fields :+     +         * 'Proto.Google.Protobuf.Descriptor_Fields.namePart' @:: Lens' UninterpretedOption'NamePart Data.Text.Text@+         * 'Proto.Google.Protobuf.Descriptor_Fields.isExtension' @:: Lens' UninterpretedOption'NamePart Prelude.Bool@ -}+data UninterpretedOption'NamePart+  = UninterpretedOption'NamePart'_constructor {_UninterpretedOption'NamePart'namePart :: !Data.Text.Text,+                                               _UninterpretedOption'NamePart'isExtension :: !Prelude.Bool,+                                               _UninterpretedOption'NamePart'_unknownFields :: !Data.ProtoLens.FieldSet}+  deriving (Prelude.Eq, Prelude.Ord)+instance Prelude.Show UninterpretedOption'NamePart where+  showsPrec _ __x __s+    = Prelude.showChar+        '{'+        (Prelude.showString+           (Data.ProtoLens.showMessageShort __x) (Prelude.showChar '}' __s))+instance Data.ProtoLens.Field.HasField UninterpretedOption'NamePart "namePart" Data.Text.Text where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _UninterpretedOption'NamePart'namePart+           (\ x__ y__ -> x__ {_UninterpretedOption'NamePart'namePart = y__}))+        Prelude.id+instance Data.ProtoLens.Field.HasField UninterpretedOption'NamePart "isExtension" Prelude.Bool where+  fieldOf _+    = (Prelude..)+        (Lens.Family2.Unchecked.lens+           _UninterpretedOption'NamePart'isExtension+           (\ x__ y__+              -> x__ {_UninterpretedOption'NamePart'isExtension = y__}))+        Prelude.id+instance Data.ProtoLens.Message UninterpretedOption'NamePart where+  messageName _+    = Data.Text.pack "google.protobuf.UninterpretedOption.NamePart"+  fieldsByTag+    = let+        namePart__field_descriptor+          = Data.ProtoLens.FieldDescriptor+              "name_part"+              (Data.ProtoLens.ScalarField Data.ProtoLens.StringField ::+                 Data.ProtoLens.FieldTypeDescriptor Data.Text.Text)+              (Data.ProtoLens.PlainField+                 Data.ProtoLens.Required+                 (Data.ProtoLens.Field.field @"namePart")) ::+              Data.ProtoLens.FieldDescriptor UninterpretedOption'NamePart+        isExtension__field_descriptor+          = Data.ProtoLens.FieldDescriptor+              "is_extension"+              (Data.ProtoLens.ScalarField Data.ProtoLens.BoolField ::+                 Data.ProtoLens.FieldTypeDescriptor Prelude.Bool)+              (Data.ProtoLens.PlainField+                 Data.ProtoLens.Required+                 (Data.ProtoLens.Field.field @"isExtension")) ::+              Data.ProtoLens.FieldDescriptor UninterpretedOption'NamePart+      in+        Data.Map.fromList+          [(Data.ProtoLens.Tag 1, namePart__field_descriptor),+           (Data.ProtoLens.Tag 2, isExtension__field_descriptor)]+  unknownFields+    = Lens.Family2.Unchecked.lens+        _UninterpretedOption'NamePart'_unknownFields+        (\ x__ y__+           -> x__ {_UninterpretedOption'NamePart'_unknownFields = y__})+  defMessage+    = UninterpretedOption'NamePart'_constructor+        {_UninterpretedOption'NamePart'namePart = Data.ProtoLens.fieldDefault,+         _UninterpretedOption'NamePart'isExtension = Data.ProtoLens.fieldDefault,+         _UninterpretedOption'NamePart'_unknownFields = []}+  parseMessage+    = let+        loop ::+          UninterpretedOption'NamePart+          -> Prelude.Bool+             -> Prelude.Bool+                -> Data.ProtoLens.Encoding.Bytes.Parser UninterpretedOption'NamePart+        loop x required'isExtension required'namePart+          = do end <- Data.ProtoLens.Encoding.Bytes.atEnd+               if end then+                   do (let+                         missing+                           = (if required'isExtension then (:) "is_extension" else Prelude.id)+                               ((if required'namePart then (:) "name_part" else Prelude.id) [])+                       in+                         if Prelude.null missing then+                             Prelude.return ()+                         else+                             Prelude.fail+                               ((Prelude.++)+                                  "Missing required fields: "+                                  (Prelude.show (missing :: [Prelude.String]))))+                      Prelude.return+                        (Lens.Family2.over+                           Data.ProtoLens.unknownFields (\ !t -> Prelude.reverse t) x)+               else+                   do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt+                      case tag of+                        10+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)+                                       (do value <- do len <- Data.ProtoLens.Encoding.Bytes.getVarInt+                                                       Data.ProtoLens.Encoding.Bytes.getBytes+                                                         (Prelude.fromIntegral len)+                                           Data.ProtoLens.Encoding.Bytes.runEither+                                             (case Data.Text.Encoding.decodeUtf8' value of+                                                (Prelude.Left err)+                                                  -> Prelude.Left (Prelude.show err)+                                                (Prelude.Right r) -> Prelude.Right r))+                                       "name_part"+                                loop+                                  (Lens.Family2.set (Data.ProtoLens.Field.field @"namePart") y x)+                                  required'isExtension+                                  Prelude.False+                        16+                          -> do y <- (Data.ProtoLens.Encoding.Bytes.<?>)+                                       (Prelude.fmap+                                          ((Prelude./=) 0) Data.ProtoLens.Encoding.Bytes.getVarInt)+                                       "is_extension"+                                loop+                                  (Lens.Family2.set (Data.ProtoLens.Field.field @"isExtension") y x)+                                  Prelude.False+                                  required'namePart+                        wire+                          -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire+                                        wire+                                loop+                                  (Lens.Family2.over+                                     Data.ProtoLens.unknownFields (\ !t -> (:) y t) x)+                                  required'isExtension+                                  required'namePart+      in+        (Data.ProtoLens.Encoding.Bytes.<?>)+          (do loop Data.ProtoLens.defMessage Prelude.True Prelude.True)+          "NamePart"+  buildMessage+    = \ _x+        -> (Data.Monoid.<>)+             ((Data.Monoid.<>)+                (Data.ProtoLens.Encoding.Bytes.putVarInt 10)+                ((Prelude..)+                   (\ bs+                      -> (Data.Monoid.<>)+                           (Data.ProtoLens.Encoding.Bytes.putVarInt+                              (Prelude.fromIntegral (Data.ByteString.length bs)))+                           (Data.ProtoLens.Encoding.Bytes.putBytes bs))+                   Data.Text.Encoding.encodeUtf8+                   (Lens.Family2.view (Data.ProtoLens.Field.field @"namePart") _x)))+             ((Data.Monoid.<>)+                ((Data.Monoid.<>)+                   (Data.ProtoLens.Encoding.Bytes.putVarInt 16)+                   ((Prelude..)+                      Data.ProtoLens.Encoding.Bytes.putVarInt+                      (\ b -> if b then 1 else 0)+                      (Lens.Family2.view+                         (Data.ProtoLens.Field.field @"isExtension") _x)))+                (Data.ProtoLens.Encoding.Wire.buildFieldSet+                   (Lens.Family2.view Data.ProtoLens.unknownFields _x)))+instance Control.DeepSeq.NFData UninterpretedOption'NamePart where+  rnf+    = \ x__+        -> Control.DeepSeq.deepseq+             (_UninterpretedOption'NamePart'_unknownFields x__)+             (Control.DeepSeq.deepseq+                (_UninterpretedOption'NamePart'namePart x__)+                (Control.DeepSeq.deepseq+                   (_UninterpretedOption'NamePart'isExtension x__) ()))